{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "c22f4718",
   "metadata": {},
   "source": [
    "# SimPy 仿真快速上手教程之我的赛博机场 🛫\n",
    "\n",
    "最近的课程大作业的选题可以是基于 SimPy 的仿真项目，所以我快速写个 SimPy 入门教程，方便大家上手。\n",
    "\n",
    "考虑到大家读写代码的实际能力和实际情况，这份教程我会做到 **尽可能事无巨细。** 📝\n",
    "\n",
    "我这里拿一个机场的例子给大家举例。毕竟谁没有梦想过，拥有一个自己的机场呢，对不对？既然我们没有办法拥有一个真正的机场，那么拥有一个在计算机里能够跑起来的仿真机场，或许可以给我们无法实现的童年梦想一个慰藉（bushi）"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e89bae65",
   "metadata": {},
   "source": [
    "## 导入所需要的库包 📦\n",
    "\n",
    "- `time`：用来处理时间 ⏰。内建工具包，无需 `pip` 安装。**在 SimPy 中，时间是直接用一个 float 类型的变量储存的。我们可以用 time 内建工具包转化为 h-m-s 的格式**。\n",
    "- `numpy`：**numpy 工具包在仿真中的实际作用主要是建立各种各样的概率分布**。比如在排队论当中，有大量的事件都是以概率的形式描述的，比如一组服务时间，就可能是一组正态分布，所以我们需要能拍工具包来帮我们计算正态分布。具体符合什么分布可以查论\n",
    "- `simpy` **离散事件仿真工具包**。可以用下面的命令安装 📥：\n",
    "\n",
    "```bash\n",
    "pip install simpy\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "6d40872f",
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import simpy"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9db5ed42",
   "metadata": {},
   "source": [
    "## 手把手教你建一个属于自己的仿真机场"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5dad9b2a",
   "metadata": {},
   "source": [
    "### 揪心的玩笑和漫长的白日梦 🌝\n",
    "\n",
    "建立一个仿真机场的第一步就是做白日梦。\n",
    "\n",
    "首先先不要考虑仿真过程具体怎么实现，脑子里先描绘一副想象中的仿真的机场的样子。比如我想要一个很大的机场，这个机场要有两条跑道、八个登机口、三个地勤组；而且我的机场必须非常繁忙非常热闹，富得流油，每隔十分钟就会有一架航班抵达。而且我的地勤组很牛逼，半个小时就能整备好一架飞机。\n",
    "\n",
    "在这种情况下，我首先设置一组机场的参数。这组参数相当于机场的指标的描述性信息："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "de8a6167",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 跑道、登机口和地勤小组的数量\n",
    "RUNWAR_NUM = 2\n",
    "GATEWAY_NUM = 8 \n",
    "GROUND_SERVICE_GROUP_NUM = 3\n",
    "\n",
    "# 航班抵达的时间间隔、着陆和起飞花费的时间\n",
    "AIRWAY_TIME_GAP = 10 * 60\n",
    "AIRWAY_TIME_LANDING = 10 * 60\n",
    "AIRWAY_TIME_TAKEOFF = 5 * 60\n",
    "\n",
    "# 地勤组工作所需的时间\n",
    "GROUND_SERVICE_TIME = 30 * 60\n",
    "\n",
    "# 将会到达的飞机数量\n",
    "TOTAL_PLANE_NUM = 10"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb643c24",
   "metadata": {},
   "source": [
    "不用担心漏掉什么参数——因为你发现之后随时可以上来补上。很方便的。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8b97d8e",
   "metadata": {},
   "source": [
    "### 理清楚一个机场的逻辑\n",
    "\n",
    "搞仿真的第二个重要步骤就是你得弄清楚这个机场每天都在干什么。首先，我们来整理一下我们想象中的这个机场每天会发生的事情。\n",
    "\n",
    "**简单的来讲，机场每天会发生下面的几件事情：**\n",
    "\n",
    "1. 每天都会有飞机抵达机场。飞机抵达机场之后，首先会申请占用跑道。\n",
    "\n",
    "2. 获得占用跑道的申请之后，就会着陆，占用跑道一段时间；\n",
    "\n",
    "3. 等到飞机降落之后就会离开跑道，来到停机坪，也就是登机口的位置。\n",
    "\n",
    "4. 然后经过地勤30分钟的打理之后，离开登机口，再次申请跑道起飞，然后继续占用跑道一段时间。\n",
    "\n",
    "虽然排队论我没有学明白，但是如果我没搞错的话，在排队论当中应该是有服务台和仓库的概念的。我们这里也可以把跑道和地勤组考虑为服务台，把登机口考虑为仓库。\n",
    "\n",
    "为什么要这样考虑呢？我也不知道为什么要这样考虑，只是觉得这样行得通，所以就这样考虑了，但是我排队论学得很烂，所以我说不准。问题就在于，比如这个跑道跑道能不能考虑为一个仓库呢？反正两根跑道对吧，容量是有限的。然后把飞机考虑为货。还是应该把登机口考虑为服务台呢？到底哪一种方案更好，我也说不准。反正我这里就先按照自己的感觉这样设计了。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "161d6fab",
   "metadata": {},
   "source": [
    "**下面这张图直观地展示了我们现在的思路。**\n",
    "\n",
    "其中，方块表示服务台，圆柱形表示仓库对象。每一家进入机场的航班，就在下图中的箭线表示的路径上排队。\n",
    "\n",
    "![极简机场仿真](./image/simAirport.drawio.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "311a0e80",
   "metadata": {},
   "source": [
    "### SimPy 如何实现这种逻辑\n",
    "\n",
    "可以参考知乎文章 [Python SimPy 仿真系列 (1)](https://zhuanlan.zhihu.com/p/31526894)，里面说的详细。我这边就举几个简单的。\n",
    "\n",
    "#### 虚拟环境\n",
    "\n",
    "- `env.Environment()` SimPy 的虚拟环境\n",
    "\n",
    "在虚拟环境下逻辑地实现的基本工具主要是这几个：\n",
    "\n",
    "#### Store - 抽象队列 📦\n",
    "\n",
    "- `simpy.Store` - 存取 item 遵循仿真时间上的先到后到\n",
    "- `simpy.Container` - 表达连续/不可分的物质, 包括液体/气体的存放, 存取的是一个 float 数值\n",
    "\n",
    "#### Resource - 抽象资源 💁\n",
    "\n",
    "- `simpy.Resource` - 表达人力资源或某种限制条件, 例如某个工序可调用的工人数, 可以调用的机器数"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5dc9865e",
   "metadata": {},
   "source": [
    "### 定义机场类\n",
    "\n",
    "我们现在需要定义一个新的类，叫做机场。\n",
    "\n",
    "**你会看见我下面的代码里面定义停机坪 / 登机口用的是 `simpy.Container` 而不是 `simpy.Store`，这是因为我研究 `simpy.Store` 一直报错而中文互联网上资料又特别少，为了赶着出这份教程，直接用了 `simpy.Container` 临时代替。这个做法是不对的，毕竟飞机不是什么能够装在杯子里流来流去的东西。但是我这边 `simpy.Store` 一直出问题。**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "1d1b8bf7",
   "metadata": {},
   "outputs": [],
   "source": [
    "class AirPort():\n",
    "    def __init__(\n",
    "        self, env, \n",
    "        num_runway, # 机场的跑道数量\n",
    "        num_gateway, # 机场的登机口数量\n",
    "        num_gs_group, # 机场的地勤组数量\n",
    "        ):\n",
    "        \n",
    "        self.env = env # 仿真环境对象\n",
    "        # 两个服务台对象\n",
    "        self.runway = simpy.Resource(\n",
    "            env, capacity=num_runway)\n",
    "        self.gs_group = simpy.Resource(\n",
    "            env, capacity=num_gs_group)\n",
    "        # 一个仓库对象\n",
    "        self.gateway = simpy.Container(\n",
    "            env, capacity=num_gateway, \n",
    "            init=0) # 初始状态下这里会有 0 架飞机\n",
    "        self.airplane_record_dict = {\n",
    "            'id' : [],\n",
    "            'arrival_time' : [],\n",
    "            'takeoff_time' : []\n",
    "        }\n",
    "        # 准备一个字典，记录每架飞机的信息\n",
    "\n",
    "        # 使用字典的方式保存每一架飞机的信息。\n",
    "        # 这些信息将会被用于统计排队参数、数据可视化等。\n",
    "        \n",
    "    def record_plane_info(\n",
    "            self, plane_id, arrival_time, takeoff_time\n",
    "        ):\n",
    "        \"\"\" 记录飞机到达的时间、起飞的时间，追加到字典\n",
    "        \"\"\"\n",
    "        self.airplane_record_dict['id'].append(plane_id)\n",
    "        self.airplane_record_dict['arrival_time'].append(arrival_time)\n",
    "        self.airplane_record_dict['takeoff_time'].append(takeoff_time)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc6a7bbc",
   "metadata": {},
   "source": [
    "### 飞机的抵达和进场 🛬💺\n",
    "\n",
    "可以被理解为这个仿真的主事件循环。\n",
    "\n",
    "`yield` 关键字和 Python 中一种特殊的对象类型——迭代器，有关。可以不用理解 `yield` 关键字是干什么用的（不难理解，但是我觉得在这里不需要花心思去解释）。只要记住这个地方要用 `yield` 来声明就好了。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "3e369f21",
   "metadata": {},
   "outputs": [],
   "source": [
    "def airline_arrivial(\n",
    "    env, airport, # 函数要传入机场和虚拟环境\n",
    "    total_plane,  # 飞机总数\n",
    "    time_gap,     # 来飞机的时间间隔\n",
    "    time_landing  # 飞机着陆所需的时间\n",
    "    ): \n",
    "    for plane_id in range(total_plane): \n",
    "        yield env.timeout( # 延迟一段时间\n",
    "            max(\n",
    "                1, # 考虑为泊松分布。（下面详解这段代码）\n",
    "                np.random.poisson(time_gap)\n",
    "            ) )\n",
    "        print( # 每当出现一架新的航班在排队准备降落\n",
    "            \"plane No.\", plane_id, \n",
    "            \"is waiting to land\",\n",
    "            \"at time\", # 打印一下这是第几架航班\n",
    "            time.strftime(\n",
    "                \"%H:%M:%S\", \n",
    "                time.gmtime(env.now)))\n",
    "        arrival_time = env.now # 飞机的到达时间就是仿真系统现在的时间\n",
    "        with airport.runway.request() as request:\n",
    "            yield request\n",
    "            yield env.timeout(\n",
    "                max(\n",
    "                    1, \n",
    "                    np.random.poisson(time_landing)\n",
    "                ) )\n",
    "        airport.gateway.put(1)\n",
    "        env.process(ground_service(\n",
    "            env, airport, plane_id, \n",
    "            GROUND_SERVICE_TIME, \n",
    "            AIRWAY_TIME_TAKEOFF,\n",
    "            arrival_time\n",
    "        ))\n",
    "        print(\"plane No.\", plane_id, \n",
    "              \"landed at time\", \n",
    "              time.strftime(\n",
    "                  \"%H:%M:%S\", \n",
    "                  time.gmtime(env.now)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65378545",
   "metadata": {},
   "source": [
    "在上面的这段代码中，这段内容可能不好理解：\n",
    "\n",
    "```python\n",
    "yield env.timeout( # 延迟一段时间\n",
    "            max(\n",
    "                1, # 考虑为泊松分布。（下面详解这段代码）\n",
    "                np.random.poisson(time_gap)\n",
    "            ) )\n",
    "```\n",
    "\n",
    "这段内容的意思是说，首先利用 `yield` 这个关键字，让 SimPy 仿真环境中的当前进程延迟一段时间。而延迟时间的长度，是一个 `max()` 函数的返回值。\n",
    "\n",
    "我们知道，在 Python 编程语言中，`max()` 这个内建函数的作用，可以对多个数字取最大。也就是说，在这里，`yield` 关键字是在 `1` 和 `np.random.poisson(time_gap)` 之间取最大。\n",
    "\n",
    "`np.random.poisson()`，是 numpy 工具包提供的泊松分布函数。这个函数在这里的功能，是允许你传入一个 $\\lambda$ 的值，然后返回随机数，返回的随机数符合一个泊松分布。\n",
    "\n",
    "也许你想问：**为什么要把 1 和泊松分布 $P(\\lambda)$ 放在一起比大小，而不是直接拿泊松分布来生成时间呢？** 原因很简单：因为 `np.random.poisson()` 是会生成负数的，但是延迟时间不可能是负数。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a95cebc9",
   "metadata": {},
   "source": [
    "### 地勤服务的流程"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ec11706d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ground_service(\n",
    "    env, airport, plane_id, \n",
    "    operation_time, takeoff_time,\n",
    "    arrival_time):\n",
    "    with airport.gs_group.request() as request:\n",
    "        yield request\n",
    "        yield env.timeout(\n",
    "            max(\n",
    "            1, \n",
    "            np.random.poisson(operation_time)\n",
    "            # 这里是服务时间\n",
    "            # 应该为负指数分布\n",
    "        ) )\n",
    "    print(\n",
    "        \"plane No.\", plane_id, \n",
    "        \"is ready to leave at\", \n",
    "        time.strftime(\n",
    "            \"%H:%M:%S\", \n",
    "            time.gmtime(env.now)))\n",
    "    env.process(airplane_takeoff(\n",
    "        env, airport, \n",
    "        plane_id, takeoff_time,\n",
    "        arrival_time))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e389ac1",
   "metadata": {},
   "source": [
    "### 飞机的起飞和离开"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "7f440f40",
   "metadata": {},
   "outputs": [],
   "source": [
    "def airplane_takeoff(\n",
    "    env, airport, \n",
    "    plane_id, takeoff_time,\n",
    "    arrival_time):\n",
    "    with airport.runway.request() as request:\n",
    "        yield request\n",
    "        yield env.timeout(\n",
    "            max(\n",
    "            1, \n",
    "            np.random.poisson(takeoff_time)\n",
    "        ) )\n",
    "        print(\"plane No.\", plane_id, \n",
    "              \"take off at\", \n",
    "              time.strftime(\n",
    "                  \"%H:%M:%S\", \n",
    "                  time.gmtime(env.now)))\n",
    "        airport.gateway.get(1)\n",
    "        takeoff_time = env.now\n",
    "        airport.record_plane_info(\n",
    "            plane_id, arrival_time, takeoff_time)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa17c3f1",
   "metadata": {},
   "source": [
    "### 整合环境并进入进程"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "fa61b876",
   "metadata": {},
   "outputs": [],
   "source": [
    "env = simpy.Environment()\n",
    "airport = AirPort(\n",
    "    env, \n",
    "    RUNWAR_NUM, \n",
    "    GATEWAY_NUM,\n",
    "    GROUND_SERVICE_GROUP_NUM)\n",
    "airline_arrivial_process = env.process(\n",
    "    airline_arrivial(\n",
    "        env, airport,\n",
    "        TOTAL_PLANE_NUM,\n",
    "        AIRWAY_TIME_GAP,\n",
    "        AIRWAY_TIME_LANDING))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "034b581a",
   "metadata": {},
   "source": [
    "## 运行机场仿真\n",
    "\n",
    "这里给到我们的仿真机场 10000 秒的时间。给大家看看效果："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "17adacac",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "plane No. 0 is waiting to land at time 00:09:13\n",
      "plane No. 0 landed at time 00:20:02\n",
      "plane No. 1 is waiting to land at time 00:29:46\n",
      "plane No. 1 landed at time 00:39:13\n",
      "plane No. 2 is waiting to land at time 00:49:15\n",
      "plane No. 0 is ready to leave at 00:50:19\n",
      "plane No. 0 take off at 00:55:23\n",
      "plane No. 2 landed at time 00:59:43\n",
      "plane No. 1 is ready to leave at 01:08:53\n",
      "plane No. 3 is waiting to land at time 01:09:52\n",
      "plane No. 1 take off at 01:13:50\n",
      "plane No. 3 landed at time 01:19:50\n",
      "plane No. 4 is waiting to land at time 01:30:22\n",
      "plane No. 2 is ready to leave at 01:30:40\n",
      "plane No. 2 take off at 01:35:36\n",
      "plane No. 4 landed at time 01:40:34\n",
      "plane No. 3 is ready to leave at 01:49:43\n",
      "plane No. 5 is waiting to land at time 01:51:01\n",
      "plane No. 3 take off at 01:54:59\n",
      "plane No. 5 landed at time 02:01:59\n",
      "plane No. 4 is ready to leave at 02:11:57\n",
      "plane No. 6 is waiting to land at time 02:12:05\n",
      "plane No. 4 take off at 02:17:19\n",
      "plane No. 6 landed at time 02:22:00\n",
      "plane No. 7 is waiting to land at time 02:31:57\n",
      "plane No. 5 is ready to leave at 02:32:12\n",
      "plane No. 5 take off at 02:37:22\n",
      "plane No. 7 landed at time 02:42:18\n",
      "plane No. 6 is ready to leave at 02:51:46\n",
      "plane No. 8 is waiting to land at time 02:52:19\n",
      "plane No. 6 take off at 02:56:58\n",
      "plane No. 8 landed at time 03:02:23\n",
      "plane No. 7 is ready to leave at 03:12:33\n",
      "plane No. 9 is waiting to land at time 03:12:35\n",
      "plane No. 7 take off at 03:17:22\n",
      "plane No. 9 landed at time 03:23:07\n",
      "plane No. 8 is ready to leave at 03:32:15\n",
      "plane No. 8 take off at 03:37:20\n",
      "plane No. 9 is ready to leave at 03:52:34\n",
      "plane No. 9 take off at 03:57:09\n"
     ]
    }
   ],
   "source": [
    "env.run()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b193fdd",
   "metadata": {},
   "source": [
    "## 查看和分析仿真结果 📊📉📈"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "64133755",
   "metadata": {},
   "source": [
    "### 计算平均滞留时间"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "c95d2263",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>id</th>\n",
       "      <th>arrival_time</th>\n",
       "      <th>takeoff_time</th>\n",
       "      <th>stay_time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>553</td>\n",
       "      <td>3323</td>\n",
       "      <td>2770</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>1786</td>\n",
       "      <td>4430</td>\n",
       "      <td>2644</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2</td>\n",
       "      <td>2955</td>\n",
       "      <td>5736</td>\n",
       "      <td>2781</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3</td>\n",
       "      <td>4192</td>\n",
       "      <td>6899</td>\n",
       "      <td>2707</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>4</td>\n",
       "      <td>5422</td>\n",
       "      <td>8239</td>\n",
       "      <td>2817</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>5</td>\n",
       "      <td>6661</td>\n",
       "      <td>9442</td>\n",
       "      <td>2781</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>6</td>\n",
       "      <td>7925</td>\n",
       "      <td>10618</td>\n",
       "      <td>2693</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>7</td>\n",
       "      <td>9117</td>\n",
       "      <td>11842</td>\n",
       "      <td>2725</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>8</td>\n",
       "      <td>10339</td>\n",
       "      <td>13040</td>\n",
       "      <td>2701</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>9</td>\n",
       "      <td>11555</td>\n",
       "      <td>14229</td>\n",
       "      <td>2674</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   id  arrival_time  takeoff_time  stay_time\n",
       "0   0           553          3323       2770\n",
       "1   1          1786          4430       2644\n",
       "2   2          2955          5736       2781\n",
       "3   3          4192          6899       2707\n",
       "4   4          5422          8239       2817\n",
       "5   5          6661          9442       2781\n",
       "6   6          7925         10618       2693\n",
       "7   7          9117         11842       2725\n",
       "8   8         10339         13040       2701\n",
       "9   9         11555         14229       2674"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sim_res = pd.DataFrame(airport.airplane_record_dict)\n",
    "sim_res['stay_time'] = sim_res['takeoff_time'] - sim_res['arrival_time']\n",
    "sim_res"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc1715ec",
   "metadata": {},
   "source": [
    "### 数据可视化"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "b5f915b2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x2ee31f0d520>"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjAAAAGhCAYAAAB/I44UAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB8v0lEQVR4nO3deVzUdf7A8dfMMAzXAAJyCSLeF3hnanlUYtlm7tbaYWmH2wW12u52/Drd3XS7t+2wWk273LTDIyuLMq88UhQVD7xvEFC5YRhmvr8/YEYJEAYGvjPD+/l48Chmvny/75kvwpvP5/15fzSKoigIIYQQQrgRrdoBCCGEEEI4ShIYIYQQQrgdSWCEEEII4XYkgRFCCCGE25EERgghhBBuRxIYIYQQQrgdSWCEEEII4XYkgRFCCCGE25EERgghhBBuRxIYIYQQQrgdhxKY2bNnM2TIEIxGI+Hh4UycOJHMzMwax2RnZ3PnnXcSGRmJv78/AwcO5Msvv7Q/f/ToUe69917i4+Px9fWlS5cuPPfcc1RUVNQ4RqPR1PrYtGlTM1+uEEIIITyBlyMHr1mzhuTkZIYMGUJlZSX/93//R1JSEnv27MHf3x+AKVOmkJ+fz/LlywkLC2PhwoVMmjSJrVu3MmDAAPbt24fVauW9996ja9euZGRk8Kc//YmSkhJeeeWVGtf78ccf6dOnj/3z0NBQJ7xkIYQQQrg7TXM2c8zNzSU8PJw1a9YwcuRIAAICApgzZw533nmn/bjQ0FBefPFFpk2bVud5Xn75ZebMmcPhw4eBqhGY+Ph4tm/fTv/+/ZsUm9Vq5fTp0xiNRjQaTZPOIYQQQojWpSgKRUVFREdHo9XWP1Hk0AjMbxUUFAAQEhJif2z48OEsWrSI66+/nuDgYBYvXkx5eTmjR4++5HkuPofNhAkTKC8vp3v37jz22GNMmDCh3nOYTCZMJpP981OnTtG7d+8mvCohhBBCqO3EiRPExMTU+3yTExir1cr06dMZMWIEffv2tT++ePFibrnlFkJDQ/Hy8sLPz48lS5bQtWvXOs9z8OBB3nzzzRrTRwEBAbz66quMGDECrVbLl19+ycSJE1m6dGm9Sczs2bOZOXNmrcfnzp2Ln59fU1+mEEIIIVpRaWkp06ZNw2g0XvK4Jk8hPfjgg3z33XesX7++Rob08MMP8+uvvzJr1izCwsJYunQpr7/+OuvWrSMhIaHGOU6dOsWoUaMYPXo0c+fOveT1pkyZwpEjR1i3bl2dz/92BKawsJDY2Fjy8vIIDAxsykusk9lsJjU1lbFjx6LX6512XtF0ck9ci9wP1yL3w7XI/WhYYWEhYWFhFBQUXPL3d5NGYFJSUlixYgVr166tkbwcOnSIt956i4yMDHvxbb9+/Vi3bh1vv/027777rv3Y06dPM2bMGIYPH87777/f4DWHDh1Kampqvc8bDAYMBkOtx/V6fYt8k7TUeUXTyT1xLXI/XIvcD9ci96N+jX1fHFpGrSgKKSkpLFmyhFWrVhEfH1/j+dLS0qqT/qboRqfTYbVa7Z+fOnWK0aNHM2jQIObPn3/JIh2b9PR0oqKiHAlXCCGEEB7KoRGY5ORkFi5cyLJlyzAajWRnZwMQFBSEr68vPXv2pGvXrtx///288sorhIaGsnTpUlJTU1mxYgVwIXmJi4vjlVdeITc3137+yMhIAD788EO8vb0ZMGAAAF999RUffPBBg9NMQgghhGgbHEpg5syZA1BrRdH8+fO566670Ov1fPvttzzxxBPccMMNFBcX07VrVz788EPGjx8PQGpqKgcPHuTgwYO1qosvLsf5xz/+wbFjx/Dy8qJnz54sWrSIm2++uSmvUQghhJtTFIXKykosFovaoTSL2WzGy8uL8vJyt38tTaXT6fDy8mp2ixOHEpjG1Pt269atRufd37rrrru46667LnmOqVOnMnXqVEdCE0II4aEqKirIysqylym4M0VRiIyM5MSJE226R5mfnx9RUVF4e3s3+RzN6gMjhBBCtCSr1cqRI0fQ6XRER0fj7e3t1r/4rVYrxcXFBAQENKr+09MoikJFRQW5ubkcOXKEbt26Nfl9kARGCCGEy6qoqMBqtRIbG+sRPb2sVisVFRX4+Pi0yQQGwNfXF71ez7Fjx+zvRVO0zXdPCCGEW2mrv+w9lTPup3xHCCGEEMLtSAIjhBBCCLcjCYwQQgjRRo0ePZrp06erHUaTSBGvEEII0YoeeughSkpKWLZsWatdc/Xq1YwZM4bz588THBxsf/yrr75y2y0NJIERQjiNoih8vOk4hUVqRyKEaIyQkBC1Q2gymUISQjjN+oN5/P2bfbyzR8fRsyVqhyM8lKIolFZUtvpHY5q5XuyLL74gISEBX19fQkNDueaaa3jsscf43//+x/Lly9FoNGg0GlavXg3A448/Tvfu3fHz86Nz584888wzmM1mAI4ePYpWq2Xr1q01rvHvf/+buLi4GvsN/tbRo0cZM2YMAO3atUOj0dgbyv52CqlTp07885//ZMqUKQQEBBAXF8fy5cvJzc3lxhtvJCAggMTExFpxrF+/niuvvBJfX19iY2N55JFHKClp2Z8BMgIjhHCazYfPAVBh1fDo57v48sEReHvJ30nCucrMFno/+32rX3fP38fh5924X5tZWVncdtttvPTSS/z+97+nqKiIdevWcccdd3D48GFKS0tZsGABcGEUxGg0smDBAqKjo9m1axd/+tOfMBqNPPbYY3Tq1IlrrrmG+fPnM3jwYPt1bFv5XGpZcmxsLF9++SU33XQTmZmZBAYG4uvrW+/xr7/+OrNmzeKZZ57h9ddf584772T48OHcc889vPzyyzz++ONMmTKF3bt3o9FoOHToENdeey3//Oc/+eCDD8jNzSUlJYWUlBTmz5/fqPerKeQnixDCabYcPWf//12nCnn9x/0qRiOEerKysqisrOQPf/gDnTp1IiEhgYceeoiAgAB8fHwwGAxERkYSGRlpb6f/9NNPM3z4cDp16sQNN9zAX//6VxYvXmw/57Rp0/jf//6HyWQCYNu2bezatYu77777krHodDp7khQeHk5kZCRBQUH1Hj9+/Hjuv/9+unXrxrPPPkthYSFDhgzhj3/8I927d+fxxx9n7969nDlzBoDZs2czefJkpk+fTrdu3Rg+fDj/+c9/+OijjygvL2/W+3gpMgIjhHCKikor6SfyAbg+1sI3J3S8u+YQV3YLY3iXMHWDEx7FV69jz9/HqXLdxurXrx9XX301CQkJjBs3jqSkJG6++eZLJg6LFi3iP//5D4cOHaK4uJjKykoCAwPtz0+cOJHk5GSWLFnCrbfeyoIFCxgzZgydOnVqzsuqJTEx0f7/ERERACQkJNR6LCcnh8jISHbs2MHOnTv59NNP7ccoimLfBqJXr15Ojc9GRmCEEE6RcboAU6WVdn56xnZQmDSoA4oCjy7awfmSCrXDEx5Eo9Hg5+3V6h+O7MGk0+lITU3lu+++o3fv3rz55pv06NGDI0eO1Hn8xo0bmTx5MuPHj2fFihVs376dp556ioqKC/92vL29mTJlCvPnz6eiooKFCxdyzz33NPv9/K2LVyXZXnNdj9nqboqLi7n//vtJT0+3f+zYsYMDBw7QpUsXp8dnIyMwQgin2Fo9fTQ4rh0aTRlPje/B1mP5HM4r4cmvdjHnjoFuvQmfEI7SaDSMGDGCESNG8OyzzxIXF8fSpUvx9vamsLCwxrEbNmwgLi6Op556yv7YsWPHap1z2rRp9O3bl3feecc+RdUYtmkqi8XSjFdUt4EDB7Jnzx66du3q9HNfiozACCGcYsvR8wAMigsGwM/bizduHYBep2Hl7mw+23JCxeiEaF2bN29m1qxZbN26lePHj/PVV1+Rm5tLz549iY2NZdeuXWRmZpKXl4fZbKZbt24cP36czz77jEOHDvGf//yHJUuW1Dpvr169uPzyy3n88ce57bbbLlmMe7G4uDg0Gg0rVqwgNzeX4uJip73Wxx9/nA0bNpCSkkJ6ejoHDhxg2bJlpKSkOO0adZEERgjRbIqi2EdgBnUMtj+eEBPEX5N6APD3r/dwMMd5PzSFcGWBgYGsXbuW8ePH0717d55++mleffVVrrvuOqZOnUr37t0ZPHgw7du355dffmHChAnMmDGDlJQU+vfvz4YNG3jmmWfqPPe9995LRUWFQ9NHHTp0YObMmTzxxBNEREQ4NblITExkzZo17N+/nyuvvJIBAwbw7LPPEh0d7bRr1EWmkIQQzXYot4TzpWZ89Fp6RwVyeteF5/50ZWfWHsjll4Nn+fNn2/nqoeEYvBpfDCmEO+rVqxcrV66s9bjVaiUsLIzvv/++1tLnl156iZdeeqnGY3W1+T916hQJCQkMGTLEoZieeeaZWkmRrQeNzdGjR2t93W/733Tq1KnWY0OGDOGHH35wKJ7mkhEYIUSz2ZZP948NrtX3RavV8Nqk/rTz07P7dCGv/iBLq4VoiuLiYjIyMnjrrbd4+OGH1Q5HdZLACCGazZbADOlUd1vyiEAfXrypamnm+2sPs+5AbqvFJoSnSElJYdCgQYwePbrW9NEDDzxAQEBAnR8PPPCAShG3LJlCEkI029bqAt7B9SQwAEl9Ipk8tCOfbj7OXxbvYOX0kYT4e7dWiEK4vQULFti79/7W3//+d/7617/W+dzFvWQ8iSQwQohmOVNYzvFzpWg1MPCiAt66PH19bzYfOcfBnGIe+2In/50ySJZWC+EE4eHhhIeHqx1Gq5IpJCFEs9hGX3pGBmL00V/yWF9vHW/c2h9vnZYf957hk83HWyNEIYQHkgRGCNEsF+pf2jXq+D7RQTx2bdXS6n+u2MOBM0UtFpsQwnNJAiOEaJatx6o78F6i/uW37hkRz8ju7TFVWnn4f9spNzu/O6gQwrNJAiOEaLJiUyV7Tle1RB/cyBEYqFpa/cofEwn192ZfdhEvrcxsqRCFEB5KEhghRJNtP34eqwIx7XyJCmpcS3ObcKMPL/+xamn1B78cYXVmTkuEKITwUJLACCGazLb/UX39XxpyVc8Ipg6LA+Cvn+8gt8jktNiEEJ5NEhghRJPZd6B2YProt54c34seEUbyiit47IsdtVqUCyFEXSSBEUI0idliZfvxfKDpIzAAPnodb9zWH28vLT9n5vLhhqPOCVCINsZisWC1WtUOo9VIAiOEaJI9pwspM1sI8tXTtX1As87VMzKQ/7uuJwCzvtvHvuxCZ4QoPJWiQElJ6384ODq4cuVKrrjiCoKDgwkNDeV3v/sdhw4dAuCKK67g8ccfr3F8bm4uer2etWvXAmAymfjrX/9Khw4d8Pf3Z+jQoTU2X1ywYAHBwcEsX76c3r17YzAYOH78OFu2bGHs2LGEhYURFBTEqFGj2LZtW41r7du3jyuuuAIfHx969+7Njz/+iEajYenSpfZjTpw4waRJkwgODiYkJIQbb7yxzs0e1SIJjBCiSWz9XwbHtUOrbX433anDOzGmR3sqKq08IkurxaWUlkJAQOt/lJY6FGZJSQmPPvooW7du5aeffkKr1XLTTTdhtVq5/fbb+eyzz2pMmS5atIjo6GiuvPJKoGrvo40bN/LZZ5+xc+dO/vjHP3Lttddy4MCBi96KUl588UXmzp3L7t27CQ8Pp6ioiKlTp7J+/Xo2bdpEt27dGD9+PEVFVT2XLBYLEydOxM/Pj82bN/P+++/z1FNP1YjdbDYzbtw4jEYj69at45dffiEgIIBrr72WioqKpt4551I8VEFBgQIoBQUFTj1vRUWFsnTpUqWiosKp5xVNJ/dEHfd/tFWJe3yF8s7PB2s83pz7kVtUrgz6R6oS9/gK5dmlu5wVapvm7v8+ysrKlD179ihlZWUXHiwuVpSq8ZDW/SgubtZryc3NVQDll19+UbKzsxUvLy9l7dq19ueHDRumPP7444qiKMqxY8cUnU6nnDp1qsY5rr76auXJJ59UFEVR5s+frwBKenr6Ja9rsVgUo9GofP3114qiKMp3332neHl5KVlZWfZjUlNTFUBZsmSJoiiK8vHHHys9evRQrFar/RiTyaT4+voq33//fdPfhGp13tdqjf39LXshCSEcpiiKvYFdYzvwNkZYgIFX/pjIXfO38OHGY4zs3p6re0U47fzCQ/j5QXGxOtd1wIEDB3j22WfZvHkzeXl59vqUkydPcvnll5OUlMSnn37KlVdeyZEjR9i4cSPvvfceALt27cJisdC9e/ca5zSZTISGhto/9/b2JjExscYxZ86c4emnn2b16tXk5ORgsVgoLS3l+PGqrTsyMzOJjY0lMjLS/jWXXXZZjXPs2LGDgwcPYjQaazxeXl5unwZTmyQwQgiHHT1bSl5xBd5eWhJigpx67tE9wrlnRDwf/HKEv32xk5V/vpLwQB+nXkO4OY0G/P3VjqJBN9xwA3Fxcfz3v/8lOjoaq9VK3759MZvNAEyePJlHHnmEN998k4ULF5KQkEBCQgIAxcXF6HQ60tLS0Ol0Nc4bEHCh5szX17fWhqhTp07l7NmzvPHGG8TFxWEwGBg2bJhDUz/FxcUMGjSITz/9tNZz7du3b/R5WpIkMEIIh9nqX/rFBGHw0jVwtOMev64HGw+fZW9WIX/5fAcf3n2ZU+pshGgtZ8+eJTMzk//+97/2mpb169fXOObGG2/kvvvuY+XKlSxcuJApU6bYnxswYAAWi4WcnBz71zfWL7/8wjvvvMP48eOBqmLcvLw8+/M9evTgxIkTnDlzhoiIqhHOLVu21DjHwIEDWbRoEeHh4QQGBjp0/dYiRbxCCIdd6P/S9OXTl2Lw0vGfW/tj8NKy7kAeH/xypEWuI0RLadeuHaGhobz//vscPHiQVatW8eijj9Y4xt/fn4kTJ/LMM8+wd+9ebrvtNvtz3bt3Z/LkyUyZMoWvvvqKI0eO8OuvvzJ79my++eabS167W7dufPzxx+zdu5fNmzczefJkfH0vdMoeO3YsXbp0YerUqezcuZNffvmFp59+GsA+mjN58mTCwsK48cYbWbduHUeOHGH16tU88sgjnDx50llvU7NIAiOEcNhWewde59W//Fa3CCNP/643AC+tzGT36YIWu5YQzqbVavnss89IS0ujb9++zJgxg5dffrnWcZMnT2bHjh1ceeWVdOzYscZz8+fPZ8qUKfzlL3+hR48eTJw4kS1bttQ67rfmzZvH+fPnGThwIHfeeSePPPII4eHh9ud1Oh1Lly6luLiYIUOGMG3aNPsqJB+fqulaPz8/1q5dS8eOHfnDH/5Ar169uPfeeykvL3eZERmZQhJCOCSv2MThvBIABnVsmREYmzuGdmRNZi4/7j3DI//bzoqHr8TX2/lTVkK0hGuuuYY9e/bUeMxisVBYeKHP0XXXXVdv92m9Xs/MmTOZOXNmnc/fdddd3HXXXbUeHzBgQK0poZtvvrnG5z179qwxpfXLL78A0LVrV/tjkZGRfPjhh3Ve2xU4NAIze/ZshgwZgtFoJDw8nIkTJ5KZWXMX2ezsbO68804iIyPx9/dn4MCBfPnllzWOOXfuHJMnTyYwMJDg4GDuvfdein9TUb5z506uvPJKfHx8iI2N5aWXXmriSxRCOJNt9KVHhJEgP32LXkuj0fDSzYmEGw0cyi3hn9/safiLhBANWrJkCampqRw9epQff/yR++67jxEjRtClSxe1Q2s0hxKYNWvWkJyczKZNm0hNTcVsNpOUlERJSYn9mClTppCZmcny5cvZtWsXf/jDH5g0aRLbt2+3HzN58mR2795NamoqK1asYO3atdx333325wsLC0lKSiIuLo60tDRefvllnn/+ed5//30nvGQhRHM4Y/8jR4T4e/PapP4AfLr5ON/vzm6V6wrhyYqKikhOTqZnz57cddddDBkyhGXLlqkdlkMcmkJauXJljc8XLFhAeHg4aWlpjBw5EoANGzYwZ84c+5ryp59+mtdff520tDQGDBjA3r17WblyJVu2bGHw4MEAvPnmm4wfP55XXnmF6OhoPv30UyoqKvjggw/w9vamT58+pKen89prr9VIdC5mMpkwmS7sZGsbojObzfYla85gO5czzymaR+5J6/r16FkABsQG1fmet8T9GNopiHtHxDHvl2M8/sVOekf6EylLqxvF3f99mM1mFEXBarV6xD4/tuki22tSyx133MEdd9xR6/HWislqtaIoCmazudYy8cZ+rzarBqagoKqoLiTkwjz48OHDWbRoEddffz3BwcEsXryY8vJyRo8eDcDGjRsJDg62Jy9QNU+o1WrZvHkzv//979m4cSMjR47E29vbfsy4ceN48cUXOX/+PO3a1f7Lb/bs2XXOE/7www/4Odh8qDFSU1Odfk7RPHJPWp7JAhmndICGosPb+fbU9nqPdfb96G2FGH8dJ0vM3Pv+ah7sZUVWVjeeu/778PLyIjIykuLiYtdpYe8Etrb+bVVFRQVlZWWsXbuWysrKGs+VNnLLhiYnMFarlenTpzNixAj69u1rf3zx4sXccssthIaG4uXlhZ+fH0uWLLEXBmVnZ9eohoaqb9CQkBCys7Ptx8THx9c4xrZWPTs7u84E5sknn6yxRK2wsJDY2FiSkpKcWjFtNptJTU1l7Nix6PUtO/8vGkfuSevZdPgc1l+3EhXkwx2/H1nnMS15P/oOLWHinI3sL4CsoB786Yr4hr+ojXP3fx8mk4njx4/j7+9fYymwu1IUhaKiIoxGY60GdG1JWVkZvr6+jBo1CoPBUOO5i4ucL6XJCUxycjIZGRm1GvM888wz5Ofn8+OPPxIWFsbSpUuZNGkS69ats3cYbAkGg6HWmwBVVdwt8Y+2pc4rmk7uScvbfrLqB8uQTiENvtctcT96RAfz3A19eOKrXbyWepAru0U4vROwp3LXfx9arRaNRkN5eTn+btB9tyG2KRqNRoNW23Y7mZSXl6PRaPD19a01hdTY79MmJTApKSn24tuYmBj744cOHeKtt94iIyODPn36ANCvXz/WrVvH22+/zbvvvktkZCQ5OTk1zldZWcm5c+fs+zJERkZy5syZGsfYPr947wYhROuydeBtyf4vDbllSCyrM3NZuTubRz7bzoqHr8DfIB0hPJVOpyM4ONj+e8PPz8+tRy6sVisVFRWUl5e3yQRGURRKS0vJyckhODi4VvLiCIf+1SuKwsMPP8ySJUtYvXp1rWke27zVb2+KTqezZ53Dhg0jPz+ftLQ0Bg0aBMCqVauwWq0MHTrUfsxTTz2F2Wy2Z2Kpqan06NGjzukjIUTLq7RY2Xasagl1S3XgbQyNRsO/bkog/UQ+R/JK+PvXe3jx5sSGv1C4Ldsfrr/949cdKYpinz5x50SsuYKDg5s9IOFQApOcnMzChQtZtmwZRqPRXrMSFBSEr68vPXv2pGvXrtx///288sorhIaGsnTpUvtyaYBevXpx7bXX8qc//Yl3330Xs9lMSkoKt956K9HR0QDcfvvtzJw5k3vvvZfHH3+cjIwM3njjDV5//fVmvVghRNPtyy6ipMKC0ceL7hHGhr+gBQX7efP6Lf25fe4mFm09wege7bkuIUrVmETL0Wg0REVFER4e7rarqWzMZjNr165l5MiRbjml5wx6vb5ZIy82DiUwc+bMAbCvKLKZP38+d911F3q9nm+//ZYnnniCG264geLiYrp27cqHH35o31QK4NNPPyUlJYWrr74arVbLTTfdxH/+8x/780FBQfzwww8kJyczaNAgwsLCePbZZ+tdQi2EaHm2/i+D4tqhc4HlP8O6hPLAqC7MWX2IJ77aRb/YYKKD3b/IU9RPp9M55RefmnQ6HZWVlfj4+LTZBMZZHJ5Caki3bt1qdd79rZCQEBYuXHjJYxITE1m3bp0j4QkhWtCWY7b9j9SbPvqtR8d2Z8PBPHacLGDGonQW/ulyl0iuhBAtr+1VEAkhHKYoCluOVHfgjXOdOjS9Tssbtw7Az1vH5iPneHfNIbVDEkK0EklghBANOnGujJwiE3qdhn6xwWqHU0OnMH9mTqha9fh66n7ST+SrG5AQolVIAiOEaJBt+XRChyB89K5Xg3DzoBiuT4yi0qrw58+2U2yqbPiLhBBuTRIYIUSDth6z9X9xnfqXi2k0GmZNTKBDsC/Hzpby3LLdaockhGhhksAIIRq05aj6/V8aEuSn5/Vb+qPVwJfbTrJ8x2m1QxJCtCBJYIQQl3SupIKDOcVA1RJqV3ZZfAgpY6r2XXtqyS5Onm/cpnBCCPcjCYwQ4pLSqpdPdw0PIMTfu4Gj1ffI1d0Y0DGYovJKZixKp9JiVTskIUQLkARGCHFJW11g/yNHeOm0vHHLAAIMXmw5ep53VsvSaiE8kSQwQohLsq1AGhznuvUvv9Ux1I9/TKxaWv3GTwfso0hCCM8hCYwQol7lZgu7ThUArrsCqT6/HxDDjf2jsVQvrS4sd+89dIQQNUkCI4So144T+ZgtCuFGA7Eh7rfP0D8m9iWmnS8nz5fx7NIMtcMRQjiRJDBCiHptvWj/I43G/fYYCvTR88at/dFpNSxNP82S7SfVDkkI4SSSwAgh6mWvf3GTAt66DIoL4ZGrugHwzNLdHD8rS6uF8ASSwAgh6mSxKvbiV3erf/mt5DFdGBzXjmJTJX9etF2WVgvhASSBEULUaf+ZIorKK/H31tEz0qh2OM3ipdPy71v7Y/TxYvvxfP7z0wG1QxJCNJMkMEKIOtn6vwyMa4eXzv1/VMS08+OF3ycA8NbPB/n1yDmVIxJCNIf7/1QSQrQI+/5HbtT/pSET+kXzh4EdsCowY1E6BWWytFoIdyUJjBCiTu7Wgbex/n5jXzqG+HEqv4ynluxCURS1QxJCNIEkMEKIWk7ll3G6oBydVkP/jsFqh+NUAQYv+9LqFTuz+HLbKbVDEkI0gSQwQohabKMvfaMD8fP2Ujka5xvQsR2Pju0OwLPLMjiaV6JyREIIR0kCI4So5UL/F8+pf/mtB0Z1YWh8CKUVFv782XbMsrRaCLciCYwQopatR239Xzyr/uViOq2G12/pT6CPFztOFvB66n61QxJCOEASGCFEDQWlZjLPFAFVXWw9WXSwL/+6KRGAOWsOsfHQWZUjEkI0liQwQogath0/j6JAfJg/7Y0GtcNpceMTorhlcCxK9dLq/NIKtUMSQjSCJDBCiBrs9S9xnjt99FvP3tCb+DB/sgvLefIrWVothDuQBEYIUYO9/iXes6ePLuZv8OI/tw5Ar9PwXUY2i7eeUDskIUQDJIERQtiZKi2kn8wH3H8DR0clxATxl6QeADy/fA+HcotVjkgIcSmSwAgh7DJOFVBRaSUswJtOoX5qh9Pq7ruyM8O7hFJmrlpaXVEpS6uFcFWSwAi3Vlhu5sXv95NTpnYknuHi/Y80Go3K0bQ+rVbDa5P6E+ynJ+NUIa+mZqodkhCiHpLACLf28cZjzF1/lM+PyLeyM2y1N7BrOwW8vxUZ5MO//lC1tHr++qOUmCpVjkgIURf5qS/c2q6TBQAcKNCQW2RSORr3ZrUqbD1ma2DXtupffmtcnwhiQ3ypsFj55WCe2uEIIeogCYxwa3uyCgFQ0PBtRrbK0bi3Q7nF5Jea8dXr6B0dqHY4qtJoNFzVIxyAnzNzVI5GCFEXSWCE2yosN3P8XKn98xW7JIFpjl+rp48GdAxGr5MfDWN6Vicw+3KlL4wQLkh+Sgm3tfd01ehLsK8eDQrpJwo4fra0ga8S9bH1f/HkDRwdcXnnUHz1OrILy+0jfUII1yEJjHBbtl8qg+KC6RZU9Rfy1ztPqxmSW7N14PXkDRwd4aPXMaJrKAA/75NpJCFcjSQwwm3tqR6B6RVpZGBoVQKzPF0SmKbIKijj5PkytBoY0FESGBvbNNIqSWCEcDmSwAi3ZRuB6R0VSL9QBb1OQ+aZIvZly3C/o2zTR72jAwkweKkcjesYU13Iu/1EPudKZJNHIVyJQwnM7NmzGTJkCEajkfDwcCZOnEhm5oVGT0ePHkWj0dT58fnnnwOwYMGCeo/Jyan6K2f16tV1Pp+dLUWaokpFpZX9Z4oA6BVlxM8LRnULA2QUpins/V/ipP7lYtHBvvSMNKIosGa/jMII4UocSmDWrFlDcnIymzZtIjU1FbPZTFJSEiUlJQDExsaSlZVV42PmzJkEBARw3XXXAXDLLbfUOmbcuHGMGjWK8PDwGtfLzMyscdxvnxdt18GcYswWBaOPFx2CfQD4XWIUUFUHI6tGHGPrwNvW+7/U5Sr7NFKuypEIIS7m0FjxypUra3y+YMECwsPDSUtLY+TIkeh0OiIjI2scs2TJEiZNmkRAQAAAvr6++Pr62p/Pzc1l1apVzJs3r9b1wsPDCQ4OdiRE0UZcPH1ka3l/VY/2+HnrOHGujO0n8hkotRyNUlhutk+7teUOvPW5qmc476w+xJrMHCotVrxkibkQLqFZk90FBVVdUENC6v6rLS0tjfT0dN5+++16z/HRRx/h5+fHzTffXOu5/v37YzKZ6Nu3L88//zwjRoyo9zwmkwmT6UIn1sLCqh/IZrMZs9ncqNfTGLZzOfOcwnEZJ6tGDHpGBtjvhZfGytU92/P1zmyWbjtJQlSAmiG6ja2H87AqENvOlxBfXbO/tz3t30jfqACCffXkl5n59XCe263S8rT74e7kfjSsse+NRmniWLvVamXChAnk5+ezfv36Oo956KGHWL16NXv27Kn3PL1792b06NG888479scyMzNZvXo1gwcPxmQyMXfuXD7++GM2b97MwIED6zzP888/z8yZM2s9vnDhQvz82t6uup7uzd1aDhZqmdzFwmXhF76Fd5/X8P4+HUa9wsxBFnRtbz9Ch31zXMsPp7QMaW/ljq6y+3JdPjqgJS1Py9XRVibEyXskREsqLS3l9ttvp6CggMDA+ruCNzmBefDBB/nuu+9Yv349MTExtZ4vKysjKiqKZ555hr/85S91nmPjxo0MHz6crVu3MmjQoEteb9SoUXTs2JGPP/64zufrGoGJjY0lLy/vkm+Ao8xmM6mpqYwdOxa9Xu+084rGUxSFwbN+prC8kuUPDaNrmI/9nigaHSNeWkN+mZkFdw1iRJdQtcN1eXd8sIXNR87zzxt7c8vg2v+WHeWJ/0a+3pnFo5/vont4AN88PFztcBziiffDncn9aFhhYSFhYWENJjBNmkJKSUlhxYoVrF27ts7kBeCLL76gtLSUKVOm1HueuXPn0r9//waTF4DLLrus3pEeAIPBgMFgqPW4Xq9vkW+SljqvaNiJc6UUllei12noGR2MRrEAF+7JdQlR/O/X43ybcYbRPSMbOFvbVlFpZUf1hpiXdwlz6ve0J/0buapXJFrNLvbnFJNTUkmHYN+Gv8jFeNL98ARyP+rX2PfFoWo0RVFISUlhyZIlrFq1ivj4+HqPnTdvHhMmTKB9+/Z1Pl9cXMzixYu59957G3Xt9PR0oqKiHAlXeChbAW+3cCPeXrW/hSf0iwbgu4xsTJWWVo3N3ew+XUC52Uo7Pz1d2kvNUH2C/bwZFFdV+yJN7YRwDQ6NwCQnJ7Nw4UKWLVuG0Wi092UJCgqqsbLo4MGDrF27lm+//bbecy1atIjKykruuOOOWs/9+9//Jj4+nj59+lBeXs7cuXNZtWoVP/zwgyPhCg9l68Bb347Jl8WHEBnoQ3ZhOWsyc0nqI6Mw9bE1sBsUF2JfzSXqNqZnOFuOnufnfTnceXmc2uEI0eY5NAIzZ84cCgoKGD16NFFRUfaPRYsW1Tjugw8+ICYmhqSkpHrPNW/ePP7whz/UuUy6oqKCv/zlLyQkJDBq1Ch27NjBjz/+yNVXX+1IuMJD2UZg+tSTwOi0GntPmGU7pKndpcj+R41n6wez4VAe5WYZ2RNCbQ6NwDS23nfWrFnMmjXrksds2LCh3ucee+wxHnvsMUdCE22IfQQmqv7irgn9o5m7/gg/7T1DiakSf2mPX4uiKGw9JjtQN1aPCCPRQT6cLihn46Gz9n2ShBDqkI5Mwq3kl1ZwKr8MgF71jMAAJHQIolOoH+VmK6l7zrRWeG7lcF4J50oqMHhp6dvBeSv1PJVGo5HNHYVwIZLAOOh0fhnpZzVkFZSrHUqbZJs+ig3xJdCn/kp1jUbDhP4dAFgu00h1su1/1C82GIOXTuVo3MNVFyUwsl2FEOqSBMZB/7d0D/P361izP0/tUNqkxkwf2dhWI63dn8t52Um4lgv7H0n9S2MN7xKGwUvLqfwyDuQUqx2OEG2aJDAOSqweat91qkDlSNqmCwW8QQ0e2zU8gN5RgVRaFb7NyGrp0NyOfQdqqX9pNF9vHcOqmyPKNJIQ6pIExkF97QlMocqRtE2OjMBAVTEvwPJ0mUa6WE5ROUfPlqLRIJteOsg+jbRXEhgh1CQJjIMSOlT95b8/p1iWUraycrOFg9XD9vX1gPmtG6qnkX49eo6sgrIWi83dpFVPH/WIMBLkK91AHTGmR1UCk3b8PAWlsiGfEGqRBMZBkYEGjHoFi1WxT2eI1nEwp5hKq0Kwn56oIJ9GfU2HYF+GdGqHosCKHTKNZHOh/kWmjxwVG+JHt/AALFaFNQdy1Q5HiDZLEhgHaTQaYv2rVh/sPJGvbjBtzMXTR450jbUV88pqpAu2HrPVv8j0UVPYppF+ljoYIVQjCUwTdAyoTmCkkLdVNdSBtz7jE6LQaTXsOlXAkbySlgjNrZSYKtldnQzKCEzT2PrBrM7MwWKV5dRCqEESmCboWL3n3a6TksC0pt2nq97vxta/2IQGGLiiaxggxbwA6SfysVgVOgT7Eu2Guyq7gkFx7TD6eHG+1Ey6jMQKoQpJYJrANoV0MLeYYlOlytG0DVarwt6sIgB6RzW8hPq3bNNIy3acavMNyGT/o+bT67SM7N4ekGkkIdQiCUwTBHpDVJAPigK7ZRqpVZw4X0qxqRJvLy2d2/s7/PVJfSIweGk5nFtinz5pq2w7UEv/l+a5qodsKyCEmiSBaaK+1dMYO2UaqVXYCnh7RBjR6xz/tjX66O2Fl1+34WLeSouVbcdlBZIzjO7RHo2mqjYrW7YWEaLVSQLTRLaOvFLI2zqaWsB7sRurm9p9veM01jZaeLk3q4jSCguBPl50Cw9QOxy3FhpgoF9MMAA/Z8oojBCtTRKYJupb3dBu18l8dQNpI2zTPo4W8F5sdI9wjAYvTheUs/XYeWeF5la2XLR9gFbb+KXoom5Xye7UQqhGEpgmsk0hHT1bKt04W4GjWwjUxUevI6lPJADLd5xySlzu5kICIwW8zmBLYH45mIepUjpzC9GaJIFpomA/PXGhfoBs7NjSzhabyC6sqjHo2YwEBi7sjfTtrmzMFmuzY3MniqJIB14n6xMdSESggdIKC5sPn1M7HCHaFElgmsG2L9IOmUZqUbbl051C/QgweDXrXCO6hBLq7825kgp+OZjnjPDcxrGzpeQVm/DWae3fu6J5NBqNfW8kmUYSonVJAtMMtgI+aWjXsvZkVb2/faKb/0vXS6fl+sQooO01tbNNHyXGBOGj16kcjeewdeX9OTOnzfcYEqI1SQLTDAkx1YW8MoXUopxRwHsxW1O773dnt6kdxaX/S8u4omsY3jotx86Wcli2qhCi1UgC0wx9OwSh0cCp/DLyik1qh+OxnFHAe7GBHdvRIdiXkgpLmxr233JMOvC2BH+DF0M7VyWF0pVXiNYjCUwzBBi86NK+qpeGTCO1jHKzhUO5xYDzRmC0Wg2/69e2ppHOFps4nFs1OjAoThIYZ5M6GCFanyQwzZQohbwtKjO7CKsCof7ehBsNTjvvjf06ALAqM4fCcs9fBm/re9M9IoBgP2+Vo/E8tuXUvx45R1Eb+H4SwhVIAtNMibY6GBmBaRG2Dry9owPRaJzXeK1XlJGu4QFUVFr5PiPbaed1VVsvamAnnK9TmD+dw/yptCqsP9C2VrcJoRZJYJopoXol0o6TBbICoQXsPl2VGDpr+shGo9HYi3mXt4G9kS70f5Hpo5YyRrryCtGqJIFppj7Rgei0GvIuarYmnMfZBbwXsyUwGw6d9egi7LIKCxnVK+UGx8kITEu5yr6cOrfN7rUlRGuSBKaZfPQ6ukcYAdmZ2tksVoV92VVN7JqziWN9OoX50y8mCItV4dtdWU4/v6tIP5FPpVUhMtCHmHa+aofjsYZ0CiHA4EVesYmM0/KzQIiWJgmME9gKeXdKIa9THTtbQmmFBR+9lviwltk5+YbqUZhlHrwaaetF+x85s45I1OTtpeWKrmGATCMJ0RokgXGCxFhbAiN/dTmTrYC3Z2TVNF1LuKFfNBoNpB07z8nzpS1yDbVtOSb7H7UW2Z1aiNYjCYwTJHYIBqo68kohr/M4uwNvXSICfRgaX/WL/esdnjeNZLEqbDtm68ArBbwtbXTP9kDVHzM5RVITJ0RLkgTGCXpEGvHWackvNXPiXJna4XiMlizgvdiN/at6wnjiaqR92YUUmyoJMHjRM7Jl30cB4UYf+0aZqzNzVY5GCM8mCYwTeHtp6RVVXch7Kl/dYDzIxT1gWtJ1fSPR6zTszSrkwJmiFr1Wa7PtfzQwrl2LTcOJmuybO8o0khAtShIYJ7Ft7Ch1MM6RU1RObpEJrQZ6tfDIQbCfNyO7VQ39e9oojG0H6iGyfUCrsdXBrDuQR0WlVeVohPBcksA4SWJ1QztZieQctumj+DB/fL11LX69Cf0vNLXzlDomRVHsCYx04G09iR2CCAvwpthUaV8BJoRwPklgnMS2pUDGqUJpYuUEF6aPglrletf0isBXr+PY2VKPGUU7eb6MM4UmvLQa+scGqx1Om6HVahjVXVYjCdHSJIFxkq7tA/DV6yg2VXI4r0TtcNxeaxXw2vgbvLimdwTgOT1hth6r+uu/b4egVhnFEhfYl1NnSgIjREuRBMZJvHRae7fYXVLI22ytVcB7MdvWAit2nsbiAaNosv+Req7sHoaXVsPh3BKOnZU/aIRoCZLAOJGtkHfHCc+YglBLaUUlR6pHsVprBAZgZPcwAn28yCkysfnI2Va7bkuRHajVE+ijt/fdkWkkIVqGQwnM7NmzGTJkCEajkfDwcCZOnEhmZqb9+aNHj6LRaOr8+Pzzz+3H1fX8Z599VuNaq1evZuDAgRgMBrp27cqCBQua90pbQb/qQt5dpySBaY69WUUoCoQbDbQ3GlrtugYvHeMTogD42s1XI+WXVrD/TDEAg2UFkiqu7lk1JSkJjBAtw6EEZs2aNSQnJ7Np0yZSU1Mxm80kJSVRUlL113JsbCxZWVk1PmbOnElAQADXXXddjXPNnz+/xnETJ060P3fkyBGuv/56xowZQ3p6OtOnT2fatGl8//33zX/FLcg2ArP7dAGVFlk+2VRqTB/Z2KaRvt2V7dZLYNOqu+92bu9PaEDrJYHiAls/mM2Hz1FiqlQ5GiE8j5cjB69cubLG5wsWLCA8PJy0tDRGjhyJTqcjMjKyxjFLlixh0qRJBATU3IwvODi41rE27777LvHx8bz66qsA9OrVi/Xr1/P6668zbtw4R0JuVfGh/hgNXhSZKjmQU0yvVpz+8CStXcB7saGdQwk3GsgpMrF2f669sNfd2Otf4mT6SC1d2vvTMcSP4+dK+eVgHkl96v55J4RoGocSmN8qKKiaKgkJqfuHZFpaGunp6bz99tu1nktOTmbatGl07tyZBx54gLvvvtu+U+7GjRu55pprahw/btw4pk+fXm8sJpMJk8lk/7ywsOqXoNlsxmw2O/S6LsV2rvrO2SfayKYj59l+7Bxdw3yddt22ZPfpfAB6hPs36t41dE8cdV3fCD7ceJyl208yqpt7JgBbqmt4BnYMdOr3f2M4+364s1Hdw/h403F+2pvNmO6hqsQg98O1yP1oWGPfmyYnMFarlenTpzNixAj69u1b5zHz5s2jV69eDB8+vMbjf//737nqqqvw8/Pjhx9+4KGHHqK4uJhHHnkEgOzsbCIiav7lGxERQWFhIWVlZfj61k4MZs+ezcyZM2s9/sMPP+Dn59fUl1mv1NTUOh/3N2kBLd9s3IX/mR1Ov66nsyiw95QO0JCzfxvfnmj819Z3TxwVWgTgxQ+7s1jy9UkMbrYC2WyF9BNV72HxkR18m6XO96Gz7oc78y/QADpW7jzJMK9jaFTczUHuh2uR+1G/0tLSRh3X5AQmOTmZjIwM1q9fX+fzZWVlLFy4kGeeeabWcxc/NmDAAEpKSnj55ZftCUxTPPnkkzz66KP2zwsLC4mNjSUpKYnAQOdNRZjNZlJTUxk7dix6vb7W85qMbH5atJNCr2DGj7/caddtKw7kFGPetAE/bx1Tfj8WbSP272nonjhKURS+OL2e4+fK8IobwPjEqGafszVtPXYey+YttA/w5s7fj7WPbLYWZ98Pd3a12cKHs3+moMJK/MArVJkWlfvhWuR+NMw2g9KQJiUwKSkprFixgrVr1xITE1PnMV988QWlpaVMmTKlwfMNHTqUf/zjH5hMJgwGA5GRkZw5c6bGMWfOnCEwMLDO0RcAg8GAwVC7WFGv17fIN0l95x0QVzVMvC+7CKtGi8HLzf58V9mB3KrMu1dUIAaDt0Nf68x7PaFfB976+SDfZpzhD4M6OuWcrWX7yap//EPiQ/D2duw9dKaW+rfnTvR6PSO6tufHvWdYd/Ac/TqqM41ki6Wt3w9XIvejfo19XxxahaQoCikpKSxZsoRVq1YRHx9f77Hz5s1jwoQJtG/fvsHzpqen065dO3sCMmzYMH766acax6SmpjJs2DBHwlVFTDtf2vnpMVsUMrM9a2fj1qBmAe/FbHsjrdmfS35phaqxOMq2A/VgKeB1CfauvLKcWginciiBSU5O5pNPPmHhwoUYjUays7PJzs6mrKysxnEHDx5k7dq1TJs2rdY5vv76a+bOnUtGRgYHDx5kzpw5zJo1i4cffth+zAMPPMDhw4d57LHH2LdvH++88w6LFy9mxowZTXyZrUej0ZBQ3Q9mh4fsqdOa1FxCfbHuEUZ6RhoxWxRWZmSrGosjrFbF3sBuiDSwcwljelb9Ebf9RD7nStwrGRbClTmUwMyZM4eCggJGjx5NVFSU/WPRokU1jvvggw+IiYkhKSmp1jn0ej1vv/02w4YNo3///rz33nu89tprPPfcc/Zj4uPj+eabb0hNTaVfv368+uqrzJ0716WXUF+sX3U/mF2yM7VDFEWxj8D0UTmBgZo7VLuL/TlFFJZX4ueto1eUUe1wBBAV5EuvqEAUBdbsl1EYIZzFoRoYRWnc/jCzZs1i1qxZdT537bXXcu211zZ4jtGjR7N9+3ZHwnMZCR2qEhhP2dW4tZwpNHG2pAKdVkP3CPV/+d6QGM1LKzPZePgsZwrLiQj0UTukBtn6vwzs2A4vnewU4iqu6tmevVmFrNqXy+8H1F03KIRwjPyEawGJ1VNIB3KKKauwqBuMG9mTVZXwdWnvj49e/eLn2BA/BnYMRlFgxc4stcNplAv7H8n2Aa7EVgezJjNHunQL4SSSwLSAyCAfwo0GLFbF/ktZNMxVCngvZttawF2mkbbad6CW+hdX0j+2He389BSWV7LteL7a4QjhESSBaSGJsjO1w1ylgPdi1ydGo9XAjhP5HDtbonY4l3Qqv4xT+WXotBr6xwarHY64iE6rYVT3qmJeWY0khHNIAtNCEmVnaoddKOANUjmSC9obDYzoGgbA8nTXHoWxTR/1iQ7E39CsXUJECxhjX059poEjhRCNIQlMC7HtTL1TViI1SlG5maNnLzSxcyU3XDSN1NhCdjVI/xfXNqp7e7Qa2H+mmJPnG9cqXQhRP0lgWkhi9Uqkw3klFJXLpl0N2Vfd9C8qyIcQf/W6x9ZlXJ9IvHVaDuQU2+N0RVvs/V+kgNcVBft5Myiu6t78LNNIQjSbJDAtJDTAQIdgXxQFMk41bl+HtswVC3htgnz19mZkrlrMW1BmJvNMVXI1SBIYlzVGuvIK4TSSwLSgRJlGajR7AuNCBbwXm9CvA1BVB+OK00jbjp9HUaBTqB/hRtfvV9NW2ZZTbzh0VlosCNFMksC0IFsh704p5G2QbQWSK3TgrcvVvcLx99ZxKr+MbcfPqx1OLRf6v0j9iyvrEWEkOsgHU6WVjYfz1A5HCLcmCUwLSrRvKSAJzKWYLVb7xpe9o1xnBdLFfPQ6kvpEAq65GmmLvf+LTB+5Mo1GI9NIQjiJJDAtqG91Ie/xc6Wcl03c6nUot5gKixWjwYuYdr5qh1Mv295I3+zKcqluqqZKCztO5AMyAuMObNNIP+/LdcnpSCHchSQwLSjIV098mD8g/WAuxVb/0isqEK1Wo3I09buiaxjt/PTkFVew4dBZtcOxyzhViKnSSoi/N52rv9+E6xreJQyDl5ZT+WXsP1OsdjhCuC1JYFrYhY0d89UNxIW5egGvjV6nZXxCFOBaq5Hs9S9x7dBoXDcBFFV8vXUM6xIKyDSSEM0hCUwLu7ASSUZg6uOKWwjUx7Y30vcZ2ZSbXWMVyRbZ/8jtXG2fRpIERoimkgSmhdlXIkkCUydFUdjtwj1gfmtIpxCignwoMlWyOjNX7XCwWhXSjskO1O7GVsibdvw8BaXS6FKIppAEpoX1iQ5Eq4HswnJyCsvVDsflnC4op6DMjJdWQ7eIALXDaZBWq7loa4FTKkcDh/OKOV9qxkevdak9pMSlxbTzo3tEABarwpoD6ifCQrgjSWBamL/Bi67hVb+YpZC3Nlv9S9fwAAxeOpWjaRzbNNJPe3NU3ybCNn3UPzYYby/55+xOxsg0khDNIj/xWkFCh2AAdsg0Ui3uUsB7sT7RgXQO88dUaSV1j7o7C1/Y/0jqX9zNVT2qEpjVmTlYrLKcWghHSQLTCvrF2hra5asbiAvak1WV1LnT9IdGo7H3hFF7NZJ9B2pJYNzOoLh2BPp4cb7UTHp1Hx8hRONJAtMKLiylLpDGVb/hTgW8F7NNI607kMfZYpMqMZwpLOf4uVK0GhjYMViVGETTeem0jOxetUmoTCMJ4ThJYFpBr6hAvLQazpZUcLpACnltCsrMnDxfBrhfAtO5fQB9OwRisSp8m5GtSgy20ZeekYEYffSqxCCa5yrZVkCIJpMEphX46HX0iDQCMo10sb3V/V86BPsS5Od+v4BtozBfq7Q30oX6F1k+7a5GdW+PRlPVCylb/rgRwiGSwLQSW0M7KeS9wB0LeC92Q79oNBr49eg5TueXtfr1tx6THajdXWiAgf6xwQD8nCmjMEI4QhKYVmJraCc7U19g68Dbx00TmKggX/vqn69buZi32FRpTwBlBZJ7s61GkmkkIRwjCUwruXhPJCnkreKuBbwXm9BPndVI24+fx6pAbIgvkUE+rXpt4Vy2fjC/HMzDVOka21MI4Q4kgWklPSKNeHtpKSyv5NjZUrXDUV1FpZWDOUWA+04hAYxPiMJLq2H36UIO5bbezsL2/Y/iZPTF3fWJDiQi0EBphYXNh8+pHY4QbkMSmFai12ntIw07pSMvB3KKMFsUAn286BDsq3Y4TRbi782V3cIAWN6Kxbz2Hahl+sjtaTQaxsg0khAOkwSmFdl3ppamVTUKeDUajcrRNI+tqd3XO063yvSg2WJl+/F8QFYgeYoxFy2nlilmIRpHEphWZN+ZWkZgLirgdZ8OvPUZ2zsSg5eWw3klZJwqbPHr7TldSJnZQrCfni7tXX8DTNGwK7qG4a3TcvxcKYdyS9QORwi3IAlMK7KNwGScKmjze594QgGvTYDBi2t6RQCts0O1rf/L4Lh2aLXuPXolqvgbvBjauWo6ULryCtE4ksC0oi7tA/Dz1lFaYeFwKxZ8uhpFUdjr5j1gfuuG6tVIK3ZmYW3h5HSL1L94JKmDEcIxXmoH0OJKSkCnc975zGZ05eVV59U71j1WBwwK9WbrsfNkHMiiW0DbzB9PnSulsqiYIJ2WLn6aqveyOZpxT5xldIwf4dpK8nPzSdtzgiHxoS1yHUVRyNh/Gt8KM0PDvZv/3rUEF7gf7ujqWH9erignY/9pCs/mE+is7SHkfrgWuR8Na+TPNY3ioRVjhYWFBAUFUQB4xt/4QgghhOcrBIKAgoICAgPr/w3eNocAhBBCCOHWPH8K6fRpuEQG5yiz2cz333/PuHHj0Ddh+O9oXgnXvbEOg5eWLU9fg17X9nLIhz5N4+d9uTw1vid3DOvU7PM19544S6XFyuhXfuZssZl37xjIqOqaBmf6v692sWT7Ke4bGc+MsT2cfn5ncJX74Y42HsrjngVbCQ3Qs/ZvVzmlSFvuh2uR+9EIhYUQHd3gYZ6fwPj7V304i9mMxcen6pxN+OaL8/PDKzCA/PJK9hdb6RNtdF5sbiL9rJkybx+6d4lyzr1p5j1xFi/gmsFdWLDhKEsPFDBqYLzTr7HxTDll3j707xnj3O9rZ3KR++GOBvX2RWfcx0lTJbvyK+lXvdFjs8j9cC1yPxpmadyWGm3vz3+VaTSaCw3t2uDGjudLKjhdUA5AzyjPS95sq5G+351NWYVz97XJLTJxJK8EjQYGdpQGdp7I20tr7+wsq5GEuDSHEpjZs2czZMgQjEYj4eHhTJw4kczMTPvzR48eRaPR1Pnx+eefA7Bjxw5uu+02YmNj8fX1pVevXrzxxhs1rrN69eo6z5Gdne2El6w+e0O7NpjA7K1uYNcxxM95qyxcyMCOwcS086W0wsJP+8449dxpx6qWT/eIMBLk53nvnahi68r7c6YkMEJcikMJzJo1a0hOTmbTpk2kpqZiNptJSkqipHrJU2xsLFlZWTU+Zs6cSUBAANdddx0AaWlphIeH88knn7B7926eeuopnnzySd56661a18vMzKxxrvBw59cUqCGxemfqXafy1Q1EBbYGdn08pP/Lb2k0GvsojLP3RrJt4DhYtg/waKN7tAeq/sDJKSpXORohXJdDNTArV66s8fmCBQsIDw8nLS2NkSNHotPpiIyMrHHMkiVLmDRpEgEBVS3P77nnnhrPd+7cmY0bN/LVV1+RkpJS47nw8HCCg4MdCdEtJFRPIe3LKqLcbMFH78Q+NS7OtoWAJ3Tgrc+N/aOZs/oQqzNzKSgzE+TrnNES2waOQ6SBnUcLN/qQGBPEzpMFrM7MZdLgWLVDEsIlNauIt6CgagokJKTuH6hpaWmkp6fz9ttvN3ieus7Rv39/TCYTffv25fnnn2fEiBH1nsNkMmEymeyfFxZW/aI0m82YzeYGX0tj2c7VnHOG+3sR4q/nXImZjJPn6Rfj/vsBNdbu6n2gukf4O+2+OOOeOFOXUF+6hftzIKeEb3ac4o+DOjT7nKUVlWRUj17172B0mddaF1e7H+5oVLdQdp4s4Kc92fy+X2TDX3AJnnA/rFaFf367jxPny3hhYh/CjQa1Q2oyT7gfLa2x702TG9lZrVYmTJhAfn4+69evr/OYhx56iNWrV7Nnz556z7NhwwZGjRrFN998Q1JSElA1dbR69WoGDx6MyWRi7ty5fPzxx2zevJmBAwfWeZ7nn3+emTNn1np84cKF+Pn5NeEVtqx392rZm6/l5ngLV0Z6ZC/BWsxWeGyzDisaZg6sJNh9fwY16IeTGr45oaN7kJXk3tZmn29/gYa39+gI9laYOci5xcHC9Rwrhtd2eWHQKcwabMGrjS+3+Oa4lh9OVb0JoQaFh3pbCPNROSjRYkpLS7n99tsbbGTX5BGY5ORkMjIy6k1eysrKWLhwIc8880y958jIyODGG2/kueeesycvAD169KBHjws9LoYPH86hQ4d4/fXX+fjjj+s815NPPsmjjz5q/7ywsJDY2FiSkpIu+QY4ymw2k5qaytixY5u1hv+A4SB7Vx/GGhzL+PF9nRafK8s4VYh18yba+em5beJYNBrnbETorHviTH3OlfLN6+s5WKhlyJVjaN/MvxgP/XwI9hziih5RjB+f6KQoW4Yr3g93Y7UqfHRkDXnFFbTvPZRhnZu+NYW734+Vu8/ww8YdAIT6e3O2pIL3Dvozf+pAuke430pGd78frcE2g9KQJiUwKSkprFixgrVr1xITE1PnMV988QWlpaVMmTKlzuf37NnD1VdfzX333cfTTz/d4DUvu+yyepMlAIPBgMFQ+5eEXq9vkW+S5p63f8cQ4DC7Txe1mW/izJyqYu8+0UF4e3s7/fwtda+bomtEEP1jg0k/kc8Pe3O5a0TzesJsP1E19Ta0c6jLvMaGuNL9cEeje4TzRdpJ1h44x8gezZtGAve8H/uyC3n8qwwA/nRlPH+6sjNTPviVfdlF3D5vK/PvHuK2LQXc8X60lsa+Lw4NTCqKQkpKCkuWLGHVqlXEx9f/Q3nevHlMmDCB9u3b13pu9+7djBkzhqlTp/LCCy806trp6elERUU5Eq5Ls/WCOZBTRGlFpcrRtA57Aa+HrkD6rQnVq5GW7WjeaqRKi5Vtx2wrkKSAt624qno59ao2upw6v7SC+z5Ko7TCwpXdwnj82p6EB/rw2X2XM6BjMAVlZu6Yu5n1B/LUDlWoxKEEJjk5mU8++YSFCxdiNBrJzs4mOzubsrKyGscdPHiQtWvXMm3atFrnyMjIYMyYMSQlJfHoo4/az5Gbm2s/5t///jfLli3j4MGDZGRkMH36dFatWkVycnITX6brCQ/0ITLQB6tyYWmxp9tz2vNXIF3sd4lRaDWw/Xg+J86VNvk8+7KLKKmwYPTxcsshc9E0V3QLw0ur4XBuCcfOuuCu4y2o0mLl4f9t5/i5UjqG+PHmbQPwqt52JdjPm0+nDeXKbmGUVli4Z8EWVmZkqRyxUINDCcycOXMoKChg9OjRREVF2T8WLVpU47gPPviAmJiYGnUtNl988QW5ubl88sknNc4xZMgQ+zEVFRX85S9/ISEhgVGjRrFjxw5+/PFHrr766ia+TNdkW06940S+uoG0AqtVsTexaysjMOGBPlxeXbuwvBmjMFuql08PimuHzgl74wj3EOijty+Zb2tdeV/6PpN1B/Lw1et4f8oggv1qTjn7eXsxd+pgxidEUmGx8tCn21i85YRK0Qq1ODyFVNfHXXfdVeO4WbNmcfz4cbTa2qd//vnn6zzH0aNH7cc89thjHDx4kLKyMs6ePcvPP//MmDFjmvQCXZlt+fSuU57fkff4uVJKKiwYvLR0DnPRPXxawI39q6aRvm5GArO1uoGd9H9pe+zTSG0ogVm6/RTvrz0MwKuT+tEzsu4/eAxeOt68bSC3DI7FqsBjX+5k7rrDrRmqUFkbX5ynroTqLQV2tYEtBWzTZD0jjfah4Lbg2j5R6HUa9mUXkZld5PDXK4piH4EZHOeexYqi6WzbCmw+fI4Sk+fXymWcKuDxL3cCkDKmK+MTLl33qNNq+NdNCdw/sjMA//xmL698n0kTu4MIN9N2fpO4oITqLQUO55VQUObZTY32ZFUlaW1l+sgmyE/PqO5Vv4SW7zjl8NefOFdGTpEJvU7jnJ2JhVvp0t6fjiF+VFis/HLQs4tV84pN3PfRVkyVVq7qGc6Msd0b9XUajYYnx/fisWurWm+89fNBnlmWgdUqSYynkwRGRSH+3sSG+AIXOtR6qrZWwHuxCfZppCyH/zK0jb4kdAhqU1tOiCoajcY+jeTJmzuaq+tYTheU0znMn3/f2t/heq+HRnflhd/3RaOBTzYdZ/qidMyW5jeRFK5LEhiVJXYIBmCHh08jtbUl1Be7plc4ft46jp8rJd3Bgu2tx2T/o7ZuzEV1MJ46NfLPFXv49cg5AgxevD9lcJN3qp88NI7/3DoAL62G5TtOc99HWymrkM7VnkoSGJUlxnj+ztR5xSbOFJrQaKi3IM+T+Xl7MbZ3BOD4aqQLO1BLAtNWDY0PwVev40yhySNbLizecoIPNx4D4N+39KdreECzzndDv2j+O3UwPnotP2fmMvWDXyks9+wp+rZKEhiVXVhK7bkjMLbpo/hQf/wNzdo/1G3Zmtqt2JmFpZFz8+dKKjiYUwxULaEWbZOPXseIrmEA/Oxhq5G2HT/P00urOu0+OrY711Qn+s01pkc4H987FKOPF78ePcet720ir9jU8BcKtyIJjMpshbyn8ss466H/wGzTR73a4PSRzZXd2hPkqye3yMSmw2cb9TVp1d13u4YHEOLv/K0XhPvwxK68OYXlPPBxGhUWK9f2iSRlTFennn9IpxA+u+9ywgK82ZNVyKR3N3Iqv6zhLxRuQxIYlRl99HRuX9UXxVP7wbTlAl4bby+tfUno8vTGTSNtPSr1L6LKmJ5VW7Kkn8j3iD90TJUW7v8kjZwiE90jAnhlUj+0LdCksU90EJ8/MJwOwb4czivh5jkb7KOawv1JAuMCEqtHYXZ6aCFvWy7gvZhtGum7jCxMlQ0XFm6xJzAyfdTWRQX50isqEEWBNftzG/4CF6YoCs8u3c324/kE+njx/p2DCWjBqeX4MH++eHAYXcMDyCooZ9J7G9tE7622QBIYF5BY3dDOExOYsgoLh3Or/uLp08YTmMviQ4gINFBYXsmazEv/Eio3W+wjcjICIwCuqh6FcfeuvJ9sPs6irSfQauDN2wfSqRU6c0cF+bL4/mEkxgRxrqSC2/67iY2HGjeVK1yXJDAuwLYSaefJfHUDaQH7sguxKhAWYCDc6KN2OKrSaTX8LrFqFKah1Ug7TuRjtihEBBqIaefbGuEJF2erg1m7P5dKN+1vsvnwWWYu3w3A49f2ZFT39q127RD/qk0gL+8cQrGpkqnzf+XHPWda7frC+SSBcQF9ooPQaiCnyMSZwnK1w3EqmT6qyTaN9OPeM5dsDb/12IXl0xqNbOAooH9sO9r56Sksr7QXeLuT0/llPPTpNiqtChP6RXNfdfv/1mT00bPg7su4plcEFZVW7v8kjSXbT7Z6HMI5JIFxAb7eOrpHGAHPm0aSAt6aEmOC6BTqR7nZyo976//rz17/IsunRTWdVsPoHu65GqncbOG+j7dytqSC3lGBvHhTomqJuY9ex7t3DOQPAzpgsSrMWLSDDzccVSUW0TySwLiIhA6eOY0kIzA1aTQa+yjMsnpWI1msCmnSwE7UwdaV1536wSiKwpNf7SLjVCEh/t68P2UQvt7qbovhpdPyyh/7cdfwTgA8t3w3b/x4wGM7HXsqSWBcRGL1Rn2eNAJjsSrsy6ragbmtF/BezLY30tr9uZwvqaj1fGZ2EUWmSgIMXvSMNLZ2eMKFjerWHp1Ww/4zxZw8X6p2OI0yb/0Rlmw/hU6r4e3bBxLTzk/tkADQajU8d0NvZlxTtWnk6z/u5+8r9sgmkG5EEhgXkXjRCIyn/BVwJK+EMrMFX72OTqEtv9LAXXQNN9IrKpBKq8J3Gdm1nrftfzSgYzBeOvknKi4I8tMzqGPVtKI7jMKsP5DHrG/3AvDM9b0Y1iVU5Yhq0mg0/Pmabjx3Q28A5v9ylL99sdNti6TbGvnp6CJ6RhnR6zScLzVz8rxndIu0TR/1jDI6vLOsp7uxv2010qlaz9n2P5Ll06IuF2/u6MqOny0l5X/bsCpw86AYplZP17iiu0fE89qkfui0Gr7cdpIHP91GuVk2gXR1ksC4CIOXzr7Road05JUC3vrdUF0Hs/nIObILLqw8UxSFLUeqRmAGSwM7UQfbcuoNh8667E7LJaZK7vt4K/mlZvrFBvPPiX1dfjXdHwbG8O4dg/D20pK65wx3z99C8SVWCgr1SQLjQuwbO3pIIa8U8NavQ7Avg+PaoSiwYueFYt5T+WVkF5bjpdXQv7ouSoiLdY8IoEOwL6ZKKxsP56kdTi2KovC3L3awL7uIsAAD790xCB+9ukW7jTW2dwQL7h6Cv7eOjYfPMvm/m+qsUxOuQRIYF9KvOoHxlDbXthGYPtFBKkfimib0r93Ubmv19FGfDkH4ebfNnbvFpWk0GvveSK44jfTO6kN8uysbvU7De3cOJDLIvRpYDu8Sxv/uu5x2fnp2nCzgj+9tJKvAM6b1PY0kMC4koUMwUJXAuHslfE5hOXnFJrQa6BEhK2nqMj4hCp1Ww86TBRzJKwGk/4tonKvsy6lzXarof9W+M7zyQyYAf7+xL4Pi3LOOKzEmmM8fGEZkoA8Hc4q5ec5G+79R4TokgXEh3SMCMHhpKTJVcvSse/9j2V09fdS5fYDqPR9cVViAgRFdw4ALO1Rvlf4vohGGdQ7D4KXlVH4Z+8+4xu7Kh3KL+fP/0lEUmDy0I7dd1lHtkJqla7iRLx4cRnyYP6fyy/jjuxvto8rCNUgC40K8dFp7vxR37wcjBbyNY2tqt3zHKQpKzWSeqeqbIwW84lJ8vXUMr16S7ArTSEXlZu77aCtFpkqGdGrHczf0UTskp4hp58fi+4fROyqQvGITt7y/ka3Vo6RCfZLAuBhP2ZlaCngbZ1yfCLy9tBzKLeHjTUcB6BzmT1iAQd3AhMu7ykW68lqtCjMWpXMot4TIQB/emVy1ksdTtDca+N99lzOkUzuKyiu5Y95mVrvZVg6eynO+yzyEbWfqXafy1Q2kmfbaC3glgbkUo4+eq6t/Eb398yFARl9E49j6waQdP09BqVm1OP790wF+3JuDt5eW96cMor3R85LvIF89H90zlNE92lNutvKnj7bydQM7youWJwmMi7ElMBmnCt22G2SJqZIj1TU8vWQKqUG2aaSy6sZZUv8iGiOmnR/dIwKwWBXWHMhVJYaVGVn856cDAMz+fYJ9BNkT+XrreP/OwfwuMQqzReGRz7bz6eZjaofVpkkC42I6hwXg762jzGzhUK57FvLuyy5EUSAi0CBTIY0wpmc4AYYLS6alA69oLDU3d8zMLuLRxTsAuGdEPDcNimn1GFqbt5eWN24dwOShHVEUeGpJBu+sPqh2WG2WJDAuRqvV0LeDeze0kwJex/jodST1iQAgLMCbTqGusdmdcH1X9ahKYFZn5mBpxdYLBaVm7vt4K6UVFoZ3CeX/xvdstWurTafV8M+JfUke0wWAl1ZmMvu7vS61nL2tkATGBfWr7sDqrg3tpIDXcXdeHodep+F3idEu33JduI5Bce0I9PHifKmZ9BPnW+WaFqtCyv+2cexsKTHtfHnr9oFtbtNRjUbD38b1tCdu7605zJNf7WrVJFJIAuOSEmw7U7vpnkjSgddxAzq2Y9szY3nmd73VDkW4ES+dlpHdW7cr70vf72PdgTx89Frev3MwIf7erXJdV3TfyC68eFMCWg18tuUEj/xvO6ZK19yfyhNJAuOCbIW8e08XUlHpXoW8lRYr+7KrepnIFJJjjD562bVbOOwq++7ULV/Iu3zHad5bcxiAl2/uJ6OswC1DOvLW7QPR6zR8syuLaR9upbRCNoFsDZLAuKCOIX4E+eqpsFjZX93YzF0czivBVGnF31tHxxCp5RCipY3q3h6NBvZmFbbonj0Zpwp47Iuqot0HR3ex76guqrYF+eCuIfjqdaw7kMcdczerurS9rZAExgVpNBr7KIy7FfLapo96RQWildEEIVpcaIDBvnP5zy00CnO22MT9H6dRbrYyqnt7/prUo0Wu486u7NaeT6YNJchXz7bj+dzy/kZyCsvVDsujSQLjohLddGdqKeAVovXZViO1RB2M2WIleeE2TuWX0SnUj//cOkCmOusxKK4di+6/nPZGA/uyi/jjexs5ca5U7bA8liQwLsq2M7W7bSmwRzrwCtHqbP1gfjmYR7nZuUWkL3yzl02Hz+HvreO/UwYT5Kd36vk9Tc/IQL58YDixIb4cO1vKTXM2uF0pgLuQBMZF2UZgMs8UOf0HUktRFIXdp6sSrt5RsgJJiNbSJzqQiEADZWYLm484b7PBz7eeYMGGowC8fkt/ukUYnXZuT9Yx1I8vHhhOjwgjOUUmJr23ke3HW2eZe1siCYyLigryISzAgMWq2KdlXF12YTnnS83otBq6RQSoHY4QbYZGo3H65o7pJ/J5amkGANOv6UZSn0innLetiAj0YdH9l9M/Npj8UjOT525m/YE8tcPyKJLAuKiLC3l3nshXN5hGsk0fdW0fgI9ep3I0QrQtYy6qg2luV9iconLu/3grFZVWxvaO4JGrujkjxDYn2M+bT6cN5YquYZRWWLhnwRa+331G7bA8hkMJzOzZsxkyZAhGo5Hw8HAmTpxIZmam/fmjR4+i0Wjq/Pj888/txx0/fpzrr78ePz8/wsPD+dvf/kZlZc1186tXr2bgwIEYDAa6du3KggULmvdK3ZA9gXGThnb2LQSk/kWIVjeiaxjeOi3Hz5U2ax+1ikorD36yjTOFJrqGB/DapH6yorAZ/A1ezLtrMNf2iaTCYuWRRTvYlCPvpzM4lMCsWbOG5ORkNm3aRGpqKmazmaSkJEpKqv6xxMbGkpWVVeNj5syZBAQEcN111wFgsVi4/vrrqaioYMOGDXz44YcsWLCAZ5991n6dI0eOcP311zNmzBjS09OZPn0606ZN4/vvv3fiS3d97rYSabcU8AqhGn+DF0M7V20E2pxppOeW7ybt2HmMPl78d8pgjD5StNtcBi8db90+gEmDY7Aq8L9DOj5PO6l2WG7Pq+FDLli5cmWNzxcsWEB4eDhpaWmMHDkSnU5HZGTNedIlS5YwadIkAgKqaiJ++OEH9uzZw48//khERAT9+/fnH//4B48//jjPP/883t7evPvuu8THx/Pqq68C0KtXL9avX8/rr7/OuHHjmvN63YptJdLB3GKKTZU1dix2RfYl1NKBVwhVXNUznHUH8li1L4c/jezs8Nd/uvkY//v1OBoN/Oe2AcSH+bdAlG2Tl07Lizcl4qvX8uHG4zy1bA/+Pt7c2L+D2qG5rWb9RiwoqBoZCAkJqfP5tLQ00tPTefvtt+2Pbdy4kYSEBCIiIuyPjRs3jgcffJDdu3czYMAANm7cyDXXXFPjXOPGjWP69On1xmIymTCZTPbPCwurfpmazWbMZud1RLSdy5nnrE+wj5aoIB+yCsrZcfwsl3Wq+312BUXlZo5X9zvo2t63Vd4fm9a8J6Jhcj/Uc2XXqp8RW46e41xRKUYffaPvx9Zj53lu2W4A/nJNN67o3E7uYQt47JrOHDx8lF/OaHl08Q70GhjbO1ztsFxKY7/vmpzAWK1Wpk+fzogRI+jbt2+dx8ybN49evXoxfPhw+2PZ2dk1khfA/nl2dvYljyksLKSsrAxfX99a15o9ezYzZ86s9fgPP/yAn5/zW9qnpqY6/Zx1aa/TkoWWxT9uJi/adXc6PVQI4EWwt8LG1T+qEkNr3RPROHI/1BHuoyOnHN78/Ef6h174mXGp+5Fvgpd36ai0ahgQaiWmaC/ffru3NcJtk26OhwoLbMnT8vBn2/lTTyu9gl3353trKy1tXPO/JicwycnJZGRksH79+jqfLysrY+HChTzzzDNNvYRDnnzySR599FH754WFhcTGxpKUlERgoPOmNMxmM6mpqYwdOxa9vuXnho/7H2bnjwepDOzA+PGJLX69pvpo03HYvY+B8eGMHz+gVa/d2vdEXJrcD3Xt0GTywYZjFPjHMn583wbvh8ls4bZ5Wyg2F9IzIoAF912Gn7drT1e7M9v9mPfAGB5bso+Vu8+w4KCeeVMGuvQoe2uyzaA0pEnfpSkpKaxYsYK1a9cSExNT5zFffPEFpaWlTJkypcbjkZGR/PrrrzUeO3PmjP05239tj118TGBgYJ2jLwAGgwGDwVDrcb1e3yI/RFvqvL/VP67qGzrjdKFL/zLYl10MQN+YYNXibK17IhpH7oc6rukdyQcbjrH2QB463YUf8XXdD0VReHzJbnadKqSdn57/Th1CkH/dP2OFc/kaDPzntoHc//FWfs7M5b6Pt/Ppny6372vVljX254ZDq5AURSElJYUlS5awatUq4uPj6z123rx5TJgwgfbt29d4fNiwYezatYucnAtV8qmpqQQGBtK7d2/7MT/99FONr0tNTWXYsGGOhOsREjpUrUQ6drbUpXc3lQJeIVzD4E4hBBi8yCuuYFcDLRjm/3KUr7adQqfV8NbtA4mVHeRblbeXljl3DGJ4l1BKKixMmbfZ3o5CNMyhBCY5OZlPPvmEhQsXYjQayc7OJjs7m7Kymlu4Hzx4kLVr1zJt2rRa50hKSqJ3797ceeed7Nixg++//56nn36a5ORk+wjKAw88wOHDh3nsscfYt28f77zzDosXL2bGjBnNeKnuKdjPm7jQqh8qDf0wUktFpZUDZ6pGYGQJtRDq8vbScmW3MODSmztuOJjHC9V1Lv83vhcjuoa1SnyiJh991R5Tg+LaUVheyZ3zNnMwp1jtsNyCQwnMnDlzKCgoYPTo0URFRdk/Fi1aVOO4Dz74gJiYGJKSkmqdQ6fTsWLFCnQ6HcOGDeOOO+5gypQp/P3vf7cfEx8fzzfffENqair9+vXj1VdfZe7cuW1qCfXFbKMwO07mqxtIPQ7lFlNhsWI0eBHTToafhVCbbXPHnzPrTmBOnCsleeE2LFaFPwzswD0jOrVidOK3/A1efHDXEPp2CORsSQWT527i+FnZxbohDtXANLY99axZs5g1a1a9z8fFxfHtt99e8hyjR49m+/btjoTnsfrFBLNiZ5bLNrSzDXn2ig5Eo5EOk0KobXSPqqn7nScLyC0y1XiutKKS+z5O43ypmcSYIGb9PkH+3bqAIF89H90zlFvf38j+M8XcPncTi+8fRnSw/FFYH9kLyQ0k2LYUcNERGOnAK4RrCTf62Dt5r7loA0FFUXjsi53szSokLMCbd+8YJPuWuZAQf28+uXconUL9OHm+jDvmbq6VgIoLJIFxA307BKHRwOmCcpf8Zt6TVTUyJAW8QrgO2+aOqzNz7Y+9u+YwK3Zm4aXVMOeOQfLXvQsKD/Th0z9dTodgXw7nlXDnvM2cL6lQOyyXJAmMGwgweNGlfdVWDBkuVsirKIps4iiEC7qqug5m/aGzVFph7YE8Xvp+HwDPT+jDEOk54rI6BPvy6bShhBsN7MsuYur8Xykqd91VqGqRBMZNJLpoIe+p/DIKyyvR6zR0CzeqHY4QolpChyDCAgyUmCxsytEwffFOFAVuuyyWyUM7qh2eaECnMH8+nTaUdn56dp4s4J4FWyitqFQ7LJciCYybcNWdqW2jL13DjXh7ybeTEK5Cq9XYi3k/P6KjqLySQXHteH5CHynadRPdIox8fO9QjD5ebDl6nvs/TqPcbFE7LJchv3HcREJMMAA7ThY0ejVYa5ACXiFcl20aCSDCaGDO5IEYvKRo15307RDEgrsvw89bx7oDeaQs3IbZYlU7LJcgCYyb6BMdiE6rIa/YRHZhudrh2EkHXiFc15XdwggweKHTKLx1Wz/CA33UDkk0waC4dsydOhiDl5Yf9+YwY1E6Fqvr/CGrFklg3ISPXkf3iKoak50uNI0kBbxCuC6jj54v7x/K4/0ssseOmxveJYx37xyEXqdhxc4sHv9yJ9Y2nsRIAuNGbIW8rtIPpqDUzKn8qm0keskIjBAuqXN7fyJktbRHGNMjnDdvG4BOq+GLtJM8//VulyopaG2SwLiRxFhbAuMaIzC26aOYdr4E+cquw0II0dKu7RvFK39MRKOBjzYe418r97XZJEYSGDeS2CEYqNrU0RW+YXefrkqkpIBXCCFaz+8HxPDCxAQA3ltzmDdXHVQ5InVIAuNGekQa8dZpyS81c+JcWcNf0MIuFPAGqRyJEEK0LbcP7cjT1/cC4LXU/cxdd1jliFqfJDBuxNtLS6+oqkJeV2hoJwW8QgihnmlXduYvY7sD8M9v9vLp5mMqR9S6JIFxM7aNHXepvKWAqdLCwZxiQBIYIYRQS8pVXXlwdBcAnl6awVfbTqocUeuRBMbNJFY3tFN7JdKBM8VUWhWCfPVEB0lvCSGEUINGo+GxcT24a3gnFAX++vkOvtuVpXZYrUISGDdj21Ig41Shqj0A9lzUgVfakgshhHo0Gg3P/q43kwbHYFXgkc+28/O+HLXDanGSwLiZru0D8NXrKDZVcjivRLU4pAOvEEK4Dq1Ww+w/JHJDv2jMFoX7P0ljw8E8tcNqUZLAuBkvnda+bFnNaSQp4BVCCNei02p4bVI/xvaOoKLSyrSPtpJ27JzaYbUYSWDckK2QV62GdlarcmEERhIYIYRwGXqdlrduH8CV3cIorbBw1wdbyFB50UdLkQTGDfWrLuRVayXSyfNlFJsq8fbS0qV9gCoxCCGEqJvBS8f7dw7msk4hFJkquXPeZvafKVI7LKeTBMYN2UZgdp8uoFKFbdVtHXh7RBjR6+RbSAghXI2vt455dw2mX0wQ50vNTJ67mSMq1k22BPnt44biQ/0xGrwoN1s5UN2LpTVJAa8QQrg+o4+eD++5jJ6RRnKLTEz+7yZOni9VOyynkQTGDWm1GvqquDO1FPAKIYR7CPbz5pNpQ+nc3p/TBeXcMXczOYXlaoflFJLAuCk1d6aWAl4hhHAfYQEGFk67nNgQX46eLWXy3M2cK6lQO6xmkwTGTV28M3VrOldSQVZBVfbeM9LYqtcWQgjRNJFBPiycdjmRgT4cyCnmznmbKSgzqx1Ws0gC46ZsHXn3ZhViqrS02nVt00edQv0w+uhb7bpCCCGaJzbEj0//NJSwAG92ny7k7vm/UmKqVDusJpMExk3FtPOlnZ8es0UhM7v1lsftyaoa8ZHpIyGEcD9d2gfw8b1DCfLVs+14PtM+3Eq5ufX+CHYmSWDclEajIaG6H8yOVqyDsRfwygokIYRwS72iAvnonssIMHix8fBZHvwkjYrK1m/J0VySwLixftXTSLtacSWSFPAKIYT76xcbzAd3DcFHr+XnzFz+/Nl2VfqKNYckMG4soUPrrkQqN1s4lFvVCKlPdFCrXFMIIUTLuCw+hP9OGYy3Tst3Gdk89sVOrFZF7bAaTRIYN5ZYPYW0/0wRZRUtP4eZmV2ExaoQ6u9NuNHQ4tcTQgjRsq7s1p63Jw9Ep9Xw1fZTPL0sA0VxjyRGEhg3FhnkQ7jRgFW5UFzbki6ePtJoNC1+PSGEEC1vbO8IXr+lPxoNLNx8nBe+2esWSYwkMG7Otpx6x4lWSGCkgFcIITzShH7RvHhTIgBz1x/h9dT9KkfUMElg3FxiK+5MLQW8QgjhuSYNjmXmhD4A/GfVQeasPqRyRJcmCYybs+1MvaOFVyJZrQp7qxOYPpLACCGER5o6vBOPX9sTgBdX7uPDDUfVDegSJIFxc4nVK5EO55ZQVN5ybaGPni2htMKCj15LfFhAi11HCCGEuh4c3YVHruoKwHPLd7N46wmVI6qbJDBuLjTAQIdgXwAyThW22HVs00c9IgPRaaWAVwghPNmMsd2594p4AJ74cidf7zitckS1OZTAzJ49myFDhmA0GgkPD2fixIlkZmbWOm7jxo1cddVV+Pv7ExgYyMiRIykrKwNg9erVaDSaOj+2bNkCwNGjR+t8ftOmTU54yZ7HVsi7swWnkaSAVwgh2g6NRsPT1/fi9qEdsSowY1E6qXvOqB1WDQ4lMGvWrCE5OZlNmzaRmpqK2WwmKSmJkpIS+zEbN27k2muvJSkpiV9//ZUtW7aQkpKCVlt1qeHDh5OVlVXjY9q0acTHxzN48OAa1/vxxx9rHDdo0CAnvGTPYyvk3dmChbxSwCuEEG2LRqPhnzf25Q8DOlBpVUj+dBvrDuSqHZadlyMHr1y5ssbnCxYsIDw8nLS0NEaOHAnAjBkzeOSRR3jiiSfsx/Xo0cP+/97e3kRGRto/N5vNLFu2jIcffrhWb5HQ0NAax4q6tcYIzO7TUsArhBBtjVar4aWbEykzW/guI5s/fbSVj+4ZymXxIWqH5lgC81sFBVV/8YeEVL2QnJwcNm/ezOTJkxk+fDiHDh2iZ8+evPDCC1xxxRV1nmP58uWcPXuWu+++u9ZzEyZMoLy8nO7du/PYY48xYcKEemMxmUyYTCb754WFVb9wzWYzZrPziltt53LmOZurZ7gfACfOlZFTUEI7P2+nnj+3yERukQmNBrqE+rjUawfXvCdtmdwP1yL3w7W46/145aa+lJoqWXMgj7sX/MpHdw22//HsbI19bzRKE9vtWa1WJkyYQH5+PuvXrwdg06ZNDBs2jJCQEF555RX69+/PRx99xDvvvENGRgbdunWrdZ7x48cD8O2339ofy8vL46OPPmLEiBFotVq+/PJLXnrpJZYuXVpvEvP8888zc+bMWo8vXLgQPz+/prxEt/LP7TpyyzU82MtCz2DndlDcm6/h3b06wn0UnhrgntuuCyGEaJ4KC7y/T8uBQi1+OoWUPhY6+Dv/OqWlpdx+++0UFBQQGFj/qH+TE5gHH3yQ7777jvXr1xMTEwPAhg0bGDFiBE8++SSzZs2yH5uYmMj111/P7Nmza5zj5MmTxMXFsXjxYm666aZLXm/KlCkcOXKEdevW1fl8XSMwsbGx5OXlXfINcJTZbCY1NZWxY8ei1+uddt7mmrF4Jyt2ZTPj6q48NLqzU8/93tojvJJ6gOv7RvLvWxKdem5ncNV70lbJ/XAtcj9ci7vfjxJTJXd/mMb2EwWE+nuz8N4hdG7v3CymsLCQsLCwBhOYJk0hpaSksGLFCtauXWtPXgCioqIA6N27d43je/XqxfHjx2udZ/78+YSGhl5yashm6NChpKam1vu8wWDAYKi9waBer2+Rb5KWOm9T9e/YjhW7stmdVeT0uDJzqnegjglyqdf8W652T9o6uR+uRe6Ha3HX+xGs17PgnqHc/t9N7D5dyNqD5+gRHezUazT2fXEogVEUhYcffpglS5awevVq4uPjazzfqVMnoqOjay2t3r9/P9ddd12tc82fP58pU6Y0Ktj09HR7giRqs69EOun8lUi7T1eds090y8x3CiGEcB9Bvno+vnco3+/O5rbLOqoWh0MJTHJyMgsXLmTZsmUYjUays7MBCAoKwtfXF41Gw9/+9jeee+45+vXrR//+/fnwww/Zt28fX3zxRY1zrVq1iiNHjjBt2rRa1/nwww/x9vZmwIABAHz11Vd88MEHzJ07t6mv0+P1iQ5Eq4HswnJyCssJD/RxynlLKyo5klc1AiM9YIQQQgCE+HurmryAgwnMnDlzABg9enSNx+fPn89dd90FwPTp0ykvL2fGjBmcO3eOfv36kZqaSpcuXWp8zbx58xg+fDg9e/as81r/+Mc/OHbsGF5eXvTs2ZNFixZx8803OxJum+Jv8KJreAD7zxSz61QBVzspgdmXXYSiQHujgfbG2lN0QgghhBocnkJqjCeeeKJGH5i6LFy4sN7npk6dytSpUx0JTQAJHYLZf6aYHScLuLpXhFPOKR14hRBCuCLZC8mD9IutqlHZ5cSGdtKBVwghhCuSBMaDJHSwdeQtaPRoWUOkA68QQghXJAmMB+kVFYiXVsPZkgpOF5Q3+3yVFiv7smQKSQghhOuRBMaD+Oh19Ig0ArDzRH6zz3f0bAmmSit+3jriQlug3aIQQgjRRJLAeBj7xo5O2JnaNn3UM9KITqtp4GghhBCi9UgC42FsDe12OaGhnRTwCiGEcFWSwHiYC4W8+c0u5N1jL+CVDrxCCCFciyQwHqZHpBFvLy2F5ZUcO1va5PMoiiI9YIQQQrgsSWA8jF6ntSccO5rRDyanyMTZkgq0GuyFwUIIIYSrkATGA9kKeZtTB2MbfenSPgAfvc4pcQkhhBDOIgmMB7LvTN2MlUhSwCuEEMKVSQLjgWwjMBmnCrBYm1bIu/t0VfIjHXiFEEK4IklgPFCX9gH4eesorbBwOLe4See4UMArK5CEEEK4HklgPJBOq6Fv9dLnHU2ogyk2VXK0egVTrygp4BVCCOF6JIHxUBcKefMd/lrb/keRgT6EBhicGZYQQgjhFJLAeKiEZmwpIAW8QgghXJ0kMB7KthJpz+lCzBarQ1+7+5StA68kMEIIIVyTJDAeqlOoH0YfL0yVVvafKXLoa+0jMNKBVwghhIuSBMZDaTSaCztTO1DIa7ZYyaxOeGQKSQghhKuSBMaD2RvaOZDAHM4toaLSSoDBi9h2fi0UmRBCCNE8ksB4sMSLdqZurD1ZVclOrygjWq2mJcISQgghmk0SGA9mW4mUmV1EudnSqK+5UMArDeyEEEK4LklgPFiHYF9C/b2ptCrsy25cIa8U8AohhHAHksB4MI1Gc6EfTCOmkRRFkR4wQggh3IIkMB7OkULerIJy8kvNeGk1dA0PaOHIhBBCiKaTBMbDOVLIa9vAsWt4AD56XUuGJYQQQjSLJDAeztYL5mBOMSWmykseu/u0TB8JIYRwD5LAeLjwQB8iA32wKhcKdOtjW0ItBbxCCCFcnSQwbYCtkHfHifxLHicFvEIIIdyFJDBtQL/qBGbXJXamLigzc+JcGSAjMEIIIVyfJDBtQEIjViLtqx596RDsS7Cfd2uEJYQQQjSZJDBtQEL1SqQjeSUUlJnrPEYKeIUQQrgTSWDagBB/b2JDfAHYXc80knTgFUII4U4kgWkjEjsEA7CjnmmkPTICI4QQwo1IAtNGJNoLefNrPVdRaeVATtVeSTICI4QQwh1IAtNGXFhKXXsE5mBOMWaLQqCPFzHtfFs7NCGEEMJhksC0EbZC3lP5ZZwtNtV4bvfp6gZ20YFoNJpWj00IIYRwlCQwbYTRR0/n9v4A7PxNIe+FAt6gVo9LCCGEaAqHEpjZs2czZMgQjEYj4eHhTJw4kczMzFrHbdy4kauuugp/f38CAwMZOXIkZWVl9uc7deqERqOp8fGvf/2rxjl27tzJlVdeiY+PD7Gxsbz00ktNfInCxrax467fFPJKAa8QQgh341ACs2bNGpKTk9m0aROpqamYzWaSkpIoKSmxH7Nx40auvfZakpKS+PXXX9myZQspKSlotTUv9fe//52srCz7x8MPP2x/rrCwkKSkJOLi4khLS+Pll1/m+eef5/3332/my23bEutoaKcoiiyhFkII4Xa8HDl45cqVNT5fsGAB4eHhpKWlMXLkSABmzJjBI488whNPPGE/rkePHrXOZTQaiYyMrPM6n376KRUVFXzwwQd4e3vTp08f0tPTee2117jvvvscCVlcxLYSaefJfPtjJ8+XUVReiV6noWt4gEqRCSGEEI5xKIH5rYKCqr/kQ0JCAMjJyWHz5s1MnjyZ4cOHc+jQIXr27MkLL7zAFVdcUeNr//Wvf/GPf/yDjh07cvvttzNjxgy8vKrC2bhxIyNHjsTb+0JL+3HjxvHiiy9y/vx52rVrVysWk8mEyXShOLWwsGpUwWw2YzbX3X22KWzncuY5W0v39n5oNZBTZOLk2SIiAn3YeeIcAN3CA9AoFsxmi8pROs6d74knkvvhWuR+uBa5Hw1r7HvT5ATGarUyffp0RowYQd++fQE4fPgwAM8//zyvvPIK/fv356OPPuLqq68mIyODbt26AfDII48wcOBAQkJC2LBhA08++SRZWVm89tprAGRnZxMfH1/jehEREfbn6kpgZs+ezcyZM2s9/sMPP+Dn59fUl1mv1NRUp5+zNUT46sgq1bBg+c8khCh8e0ILaDFWFvDtt9+qHV6zuOs98VRyP1yL3A/XIvejfqWlpY06rskJTHJyMhkZGaxfv97+mNVqBeD+++/n7rvvBmDAgAH89NNPfPDBB8yePRuARx991P41iYmJeHt7c//99zN79mwMBkOT4nnyySdrnLewsJDY2FiSkpIIDHRebYfZbCY1NZWxY8ei1+uddt7WstaUwZfbTuMd2Y3x13Rl+afbgVzGDunF+GFxaofXJO5+TzyN3A/XIvfDtcj9aJhtBqUhTUpgUlJSWLFiBWvXriUmJsb+eFRUFAC9e/eucXyvXr04fvx4vecbOnQolZWVHD16lB49ehAZGcmZM2dqHGP7vL66GYPBUGfyo9frW+SbpKXO29L6dwzhy22n2Z1VhF6vZ192MQAJMe3c8vVczF3viaeS++Fa5H64Frkf9Wvs++LQKiRFUUhJSWHJkiWsWrWq1jRPp06diI6OrrW0ev/+/cTF1f/XfXp6OlqtlvDwcACGDRvG2rVra8yDpaam0qNHjzqnj0Tj2ZZS7zyZz/mSCk7lVy1v7yVLqIUQQrgRh0ZgkpOTWbhwIcuWLcNoNJKdnQ1AUFAQvr6+aDQa/va3v/Hcc8/Rr18/+vfvz4cffsi+ffv44osvgKoC3c2bNzNmzBiMRiMbN25kxowZ3HHHHfbk5Pbbb2fmzJnce++9PP7442RkZPDGG2/w+uuvO/nltz09o4zodRrOl5pJ3VM1qtUxxI9AH/lLQAghhPtwKIGZM2cOAKNHj67x+Pz587nrrrsAmD59OuXl5cyYMYNz587Rr18/UlNT6dKlC1A11fPZZ5/x/PPPYzKZiI+PZ8aMGTXqV4KCgvjhhx9ITk5m0KBBhIWF8eyzz8oSaicweOnoGRnIrlMF/G9L1bSe9H8RQgjhbhxKYBRFadRxTzzxRI0+MBcbOHAgmzZtavAciYmJrFu3zpHwRCMlxASx61QB24/nA9KBVwghhPuRvZDaoH4xNfc8khEYIYQQ7kYSmDYooUNwjc/7dJAERgghhHuRBKYN6h4RgMGr6ta389MTGeijckRCCCGEYySBaYO8dFr6VNe99I4ORKPRqByREEII4RhJYNqowZ2q9q/qHxusbiBCCCFEEzRrM0fhvh6+qiuxIX78YUAHtUMRQgghHCYJTBtl9NFz5+XuufeREEIIIVNIQgghhHA7ksAIIYQQwu1IAiOEEEIItyMJjBBCCCHcjiQwQgghhHA7ksAIIYQQwu1IAiOEEEIItyMJjBBCCCHcjiQwQgghhHA7ksAIIYQQwu1IAiOEEEIItyMJjBBCCCHcjiQwQgghhHA7HrsbtaIoABQWFjr1vGazmdLSUgoLC9Hr9U49t2gauSeuRe6Ha5H74VrkfjTM9nvb9nu8Ph6bwBQVFQEQGxurciRCCCGEcFRRURFBQUH1Pq9RGkpx3JTVauX06dMYjUY0Go3TzltYWEhsbCwnTpwgMDDQaecVTSf3xLXI/XAtcj9ci9yPhimKQlFREdHR0Wi19Ve6eOwIjFarJSYmpsXOHxgYKN98LkbuiWuR++Fa5H64Frkfl3apkRcbKeIVQgghhNuRBEYIIYQQbkcSGAcZDAaee+45DAaD2qGIanJPXIvcD9ci98O1yP1wHo8t4hVCCCGE55IRGCGEEEK4HUlghBBCCOF2JIERQgghhNuRBEYIIYQQbkcSGCGEEEK4HUlgHPT222/TqVMnfHx8GDp0KL/++qvaIbVJs2fPZsiQIRiNRsLDw5k4cSKZmZlqhyWq/etf/0Kj0TB9+nS1Q2nTTp06xR133EFoaCi+vr4kJCSwdetWtcNqkywWC8888wzx8fH4+vrSpUsX/vGPfzS4YaGonyQwDli0aBGPPvoozz33HNu2baNfv36MGzeOnJwctUNrc9asWUNycjKbNm0iNTUVs9lMUlISJSUlaofW5m3ZsoX33nuPxMREtUNp086fP8+IESPQ6/V899137Nmzh1dffZV27dqpHVqb9OKLLzJnzhzeeust9u7dy4svvshLL73Em2++qXZobkv6wDhg6NChDBkyhLfeeguo2jAyNjaWhx9+mCeeeELl6Nq23NxcwsPDWbNmDSNHjlQ7nDaruLiYgQMH8s477/DPf/6T/v378+9//1vtsNqkJ554gl9++YV169apHYoAfve73xEREcG8efPsj9100034+vryySefqBiZ+5IRmEaqqKggLS2Na665xv6YVqvlmmuuYePGjSpGJgAKCgoACAkJUTmSti05OZnrr7++xr8ToY7ly5czePBg/vjHPxIeHs6AAQP473//q3ZYbdbw4cP56aef2L9/PwA7duxg/fr1XHfddSpH5r48djdqZ8vLy8NisRAREVHj8YiICPbt26dSVAKqRsKmT5/OiBEj6Nu3r9rhtFmfffYZ27ZtY8uWLWqHIoDDhw8zZ84cHn30Uf7v//6PLVu28Mgjj+Dt7c3UqVPVDq/NeeKJJygsLKRnz57odDosFgsvvPACkydPVjs0tyUJjHB7ycnJZGRksH79erVDabNOnDjBn//8Z1JTU/Hx8VE7HEFVYj948GBmzZoFwIABA8jIyODdd9+VBEYFixcv5tNPP2XhwoX06dOH9PR0pk+fTnR0tNyPJpIEppHCwsLQ6XScOXOmxuNnzpwhMjJSpahESkoKK1asYO3atcTExKgdTpuVlpZGTk4OAwcOtD9msVhYu3Ytb731FiaTCZ1Op2KEbU9UVBS9e/eu8VivXr348ssvVYqobfvb3/7GE088wa233gpAQkICx44dY/bs2ZLANJHUwDSSt7c3gwYN4qeffrI/ZrVa+emnnxg2bJiKkbVNiqKQkpLCkiVLWLVqFfHx8WqH1KZdffXV7Nq1i/T0dPvH4MGDmTx5Munp6ZK8qGDEiBG1Wgvs37+fuLg4lSJq20pLS9Fqa/7K1el0WK1WlSJyfzIC44BHH32UqVOnMnjwYC677DL+/e9/U1JSwt133612aG1OcnIyCxcuZNmyZRiNRrKzswEICgrC19dX5ejaHqPRWKv+yN/fn9DQUKlLUsmMGTMYPnw4s2bNYtKkSfz666+8//77vP/++2qH1ibdcMMNvPDCC3Ts2JE+ffqwfft2XnvtNe655x61Q3NfinDIm2++qXTs2FHx9vZWLrvsMmXTpk1qh9QmAXV+zJ8/X+3QRLVRo0Ypf/7zn9UOo037+uuvlb59+yoGg0Hp2bOn8v7776sdUptVWFio/PnPf1Y6duyo+Pj4KJ07d1aeeuopxWQyqR2a25I+MEIIIYRwO1IDI4QQQgi3IwmMEEIIIdyOJDBCCCGEcDuSwAghhBDC7UgCI4QQQgi3IwmMEEIIIdyOJDBCCCGEcDuSwAghhBDC7UgCI4QQQgi3IwmMEEIIIdyOJDBCCCGEcDv/D7p/nBDoHR8nAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots()\n",
    "sim_res[['stay_time']].plot.line(\n",
    "    ax=ax)\n",
    "ax.axhline(\n",
    "    sim_res['stay_time'].mean(),\n",
    "    label='average', c='r'\n",
    ")\n",
    "ax.grid()\n",
    "ax.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "25aff0c3",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
